修复启动脚本问题

python/arm64/python-enviroment-install.py

@@ -9,8 +9,12 @@ import os
 import sys
 import subprocess
 import platform
+import tempfile
+import urllib.request
 from pathlib import Path
 
+GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py"
+
 # 脚本所在目录即本环境目录（python/arm64 或 python/x64），venv 固定为 env
 SCRIPT_DIR = Path(__file__).parent.absolute()
 PROJECT_ROOT = SCRIPT_DIR.parent.parent.absolute()
@@ -50,6 +54,24 @@ def run_command(cmd, check=True, capture_output=True):
         return False, e.stdout if hasattr(e, 'stdout') else "", str(e)
 
 
+def repair_pip_with_get_pip():
+    """pip 损坏时用官方 get-pip.py 强制重装"""
+    try:
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.py', delete=False) as f:
+            req = urllib.request.urlopen(GET_PIP_URL, timeout=30)
+            f.write(req.read())
+            get_pip_path = f.name
+        ok, _, _ = run_command(f'"{sys.executable}" "{get_pip_path}" --force-reinstall', check=False)
+        try:
+            os.unlink(get_pip_path)
+        except Exception:
+            pass
+        return ok
+    except Exception as e:
+        print(f"[WARN] 下载/执行 get-pip.py 失败: {e}")
+        return False
+
+
 def _venv_home():
     """读取 venv 的 pyvenv.cfg 中的 home（创建该 venv 的 Python 路径）"""
     cfg = VENV_PATH / "pyvenv.cfg"
@@ -97,6 +119,53 @@ def ensure_venv():
             venv_cmd = f'"{sys.executable}" -m virtualenv "{VENV_PATH}"'
             success, out, error = run_command(venv_cmd, check=False)
             merged = (error or "") + (out or "")
+
+        # virtualenv 损坏时：先删原虚拟环境，再重装 virtualenv 并重建；pip 损坏则先 ensurepip 修复
+        if not success:
+            err_msg = merged.strip() or '(no output)'
+            if "No discovery plugin found" in err_msg or "discovery plugin" in err_msg.lower():
+                import shutil
+                if VENV_PATH.exists():
+                    try:
+                        shutil.rmtree(VENV_PATH)
+                        print("[OK] 已删除原虚拟环境目录，将重新创建")
+                    except Exception as e:
+                        print(f"[WARN] 删除 env 失败: {e}")
+                print("[WARN] virtualenv 异常，正在重装 virtualenv...")
+                reinstall_ok, _, reinstall_err = run_command(
+                    f'"{sys.executable}" -m pip install --force-reinstall virtualenv',
+                    check=False
+                )
+                if not reinstall_ok and ("pip._internal" in (reinstall_err or "") or "ModuleNotFoundError" in (reinstall_err or "")):
+                    print("[WARN] pip 异常（嵌入式 pip 可能不完整），正在修复 pip...")
+                    ensure_ok, _, _ = run_command(f'"{sys.executable}" -m ensurepip --upgrade', check=False)
+                    if ensure_ok:
+                        reinstall_ok, _, reinstall_err = run_command(
+                            f'"{sys.executable}" -m pip install --force-reinstall virtualenv',
+                            check=False
+                        )
+                    if not reinstall_ok:
+                        print("[WARN] 使用官方 get-pip.py 重装 pip...")
+                        if repair_pip_with_get_pip():
+                            reinstall_ok, _, reinstall_err = run_command(
+                                f'"{sys.executable}" -m pip install --force-reinstall virtualenv',
+                                check=False
+                            )
+                    if not reinstall_ok:
+                        print(f"[X] 重装 virtualenv 失败: {reinstall_err or '(no output)'}")
+                        print("[HINT] 嵌入式 python 内 pip 不完整（缺 pip._internal.operations.build）时，可手动: 下载 get-pip.py 后执行 python get-pip.py --force-reinstall")
+                        sys.exit(1)
+                if not reinstall_ok:
+                    print(f"[X] 重装 virtualenv 失败: {reinstall_err or '(no output)'}")
+                    sys.exit(1)
+                print("[OK] virtualenv 重装完成")
+                success, out, error = run_command(f'"{sys.executable}" -m venv "{VENV_PATH}"', check=False)
+                merged = (error or "") + (out or "")
+                if not success and "No module named venv" in merged:
+                    venv_cmd = f'"{sys.executable}" -m virtualenv "{VENV_PATH}"'
+                    success, out, error = run_command(venv_cmd, check=False)
+                    merged = (error or "") + (out or "")
+
         if not success:
             print(f"[X] Failed to create virtual environment: {merged.strip() or '(no output)'}")
             sys.exit(1)

python/x64/environment.txt

@@ -55,7 +55,7 @@ platformdirs==4.9.4
 playwright==1.58.0
 prettytable==3.17.0
 primp==1.1.3
-protobuf==6.33.4
+protobuf==7.34.0
 psutil==7.2.2
 py-cpuinfo==9.0.0
 pyclipper==1.4.0
@@ -78,7 +78,7 @@ requests-toolbelt==1.0.0
 rich==14.3.3
 ruamel.yaml==0.19.1
 safetensors==0.7.0
-setuptools==80.10.2
+setuptools==82.0.1
 shapely==2.1.2
 shellingham==1.5.4
 six==1.17.0

python/x64/py/Lib/site-packages/filelock-3.24.3.dist-info/RECORD

@@ -1,26 +0,0 @@
-filelock-3.24.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-filelock-3.24.3.dist-info/METADATA,sha256=2SzY43viecqbmVNOokZgXcYTE04sufy5Rjf6wZTMWC4,1977
-filelock-3.24.3.dist-info/RECORD,,
-filelock-3.24.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-filelock-3.24.3.dist-info/licenses/LICENSE,sha256=YIyJ1QYK6ZIa3M8yNmlbxlSplG4SMj72wCHfoE4pTUg,1088
-filelock/__init__.py,sha256=12pKiL8AjSCkmWLozJhcCg6qQY70_XizYh9AHUvzZ1Q,2009
-filelock/__pycache__/__init__.cpython-312.pyc,,
-filelock/__pycache__/_api.cpython-312.pyc,,
-filelock/__pycache__/_error.cpython-312.pyc,,
-filelock/__pycache__/_read_write.cpython-312.pyc,,
-filelock/__pycache__/_soft.cpython-312.pyc,,
-filelock/__pycache__/_unix.cpython-312.pyc,,
-filelock/__pycache__/_util.cpython-312.pyc,,
-filelock/__pycache__/_windows.cpython-312.pyc,,
-filelock/__pycache__/asyncio.cpython-312.pyc,,
-filelock/__pycache__/version.cpython-312.pyc,,
-filelock/_api.py,sha256=l8P7bqosgleI3vPn8OVGQ0-sa2d3WVhvM_j9SCCcTx4,21159
-filelock/_error.py,sha256=mnelOh0EVyVeskG3rksL4kW3OArL4TMb2-PwmzQWIFg,788
-filelock/_read_write.py,sha256=o6pcX04--nXFspDXtV_J113EDH_-rzz-Hvp-cmH76P4,15313
-filelock/_soft.py,sha256=8aSSoyLZjBDV-ql3LJt_Ec_kg7ywHDE8ZZFcCtVWxQ8,4665
-filelock/_unix.py,sha256=DL0mk9OAE21wY-uhdClJ2ezBUFfi-vNszdBJCw7slqE,4233
-filelock/_util.py,sha256=wPf-LvzmdHWHw4DinDeVJlB0GNVOYGNUeNKSnHBQuUU,1716
-filelock/_windows.py,sha256=-CEBIFfFPwmfSSmTmbbGzgUR30E0jBacBW9j4_ER0YM,3508
-filelock/asyncio.py,sha256=NvrDsqS095NZc16l_OjBQcTY-D6xB4Vy7AK3ni8tr8A,13943
-filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-filelock/version.py,sha256=cEVcBJgzKOmekaY1NFrR1sXy1-sBY4F7inrTVfovZUA,706

python/x64/py/Lib/site-packages/filelock-3.24.3.dist-info/METADATA → python/x64/py/Lib/site-packages/filelock-3.25.2.dist-info/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: filelock
-Version: 3.24.3
+Version: 3.25.2
 Summary: A platform independent file lock.
 Project-URL: Documentation, https://py-filelock.readthedocs.io
 Project-URL: Homepage, https://github.com/tox-dev/py-filelock

python/x64/py/Lib/site-packages/filelock-3.25.2.dist-info/RECORD

@@ -0,0 +1,28 @@
+filelock-3.25.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.25.2.dist-info/METADATA,sha256=CHiP5bKcITUrdDKmfCvMspEdKUj5vuPq3udl5JA3Yj4,1977
+filelock-3.25.2.dist-info/RECORD,,
+filelock-3.25.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+filelock-3.25.2.dist-info/licenses/LICENSE,sha256=YIyJ1QYK6ZIa3M8yNmlbxlSplG4SMj72wCHfoE4pTUg,1088
+filelock/__init__.py,sha256=-eghH1rpZitcXkHLNqZS1w-3_rmb-zsYFyVA8n1MK44,2305
+filelock/__pycache__/__init__.cpython-312.pyc,,
+filelock/__pycache__/_api.cpython-312.pyc,,
+filelock/__pycache__/_async_read_write.cpython-312.pyc,,
+filelock/__pycache__/_error.cpython-312.pyc,,
+filelock/__pycache__/_read_write.cpython-312.pyc,,
+filelock/__pycache__/_soft.cpython-312.pyc,,
+filelock/__pycache__/_unix.cpython-312.pyc,,
+filelock/__pycache__/_util.cpython-312.pyc,,
+filelock/__pycache__/_windows.cpython-312.pyc,,
+filelock/__pycache__/asyncio.cpython-312.pyc,,
+filelock/__pycache__/version.cpython-312.pyc,,
+filelock/_api.py,sha256=l8P7bqosgleI3vPn8OVGQ0-sa2d3WVhvM_j9SCCcTx4,21159
+filelock/_async_read_write.py,sha256=f6QwJ5ENUwircnNhvdkTm4I2nYV5nY-rvnYgs7NZBLc,7545
+filelock/_error.py,sha256=mnelOh0EVyVeskG3rksL4kW3OArL4TMb2-PwmzQWIFg,788
+filelock/_read_write.py,sha256=5tVPm1TDXvAu0sgva_LQJ4DH-SDo0rVxuYAFLEQGZw4,15323
+filelock/_soft.py,sha256=Qar4H767G4zbkJFadMvtn5m0uBCYpHcVk2BfNmLrA1o,4677
+filelock/_unix.py,sha256=pbTsIi29Qv8zBtLsXqc3PzlS3wz2db53M1MIqVo9790,4579
+filelock/_util.py,sha256=wPf-LvzmdHWHw4DinDeVJlB0GNVOYGNUeNKSnHBQuUU,1716
+filelock/_windows.py,sha256=kJFOenaffOP6Qza2b3-yxgiPiDcyroWnzz9STGkCrgM,3943
+filelock/asyncio.py,sha256=NvrDsqS095NZc16l_OjBQcTY-D6xB4Vy7AK3ni8tr8A,13943
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=p1u3I6A9nX3mbHkvyJTo-_u506UHBhmP9NaOUwHULRE,706

python/x64/py/Lib/site-packages/filelock/__init__.py

@@ -16,8 +16,11 @@ from ._api import AcquireReturnProxy, BaseFileLock
 from ._error import Timeout
 
 try:
+    from ._async_read_write import AsyncAcquireReadWriteReturnProxy, AsyncReadWriteLock
     from ._read_write import ReadWriteLock
 except ImportError:  # sqlite3 may be unavailable if Python was built without it or the C library is missing
+    AsyncAcquireReadWriteReturnProxy = None  # type: ignore[assignment, misc]
+    AsyncReadWriteLock = None  # type: ignore[assignment, misc]
     ReadWriteLock = None  # type: ignore[assignment, misc]
 
 from ._soft import SoftFileLock
@@ -60,8 +63,10 @@ else:
 
 __all__ = [
     "AcquireReturnProxy",
+    "AsyncAcquireReadWriteReturnProxy",
     "AsyncAcquireReturnProxy",
     "AsyncFileLock",
+    "AsyncReadWriteLock",
     "AsyncSoftFileLock",
     "AsyncUnixFileLock",
     "AsyncWindowsFileLock",

python/x64/py/Lib/site-packages/filelock/_async_read_write.py

@@ -0,0 +1,203 @@
+"""Async wrapper around :class:`ReadWriteLock` for use with ``asyncio``."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING
+
+from ._read_write import ReadWriteLock
+
+if TYPE_CHECKING:
+    import os
+    from collections.abc import AsyncGenerator, Callable
+    from concurrent import futures
+    from types import TracebackType
+
+
+class AsyncAcquireReadWriteReturnProxy:
+    """Context-aware object that releases the async read/write lock on exit."""
+
+    def __init__(self, lock: AsyncReadWriteLock) -> None:
+        self.lock = lock
+
+    async def __aenter__(self) -> AsyncReadWriteLock:
+        return self.lock
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.lock.release()
+
+
+class AsyncReadWriteLock:
+    """
+    Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications.
+
+    Because Python's :mod:`sqlite3` module has no async API, all blocking SQLite operations are dispatched to a thread
+    pool via ``loop.run_in_executor()``. Reentrancy, upgrade/downgrade rules, and singleton behavior are delegated
+    to the underlying :class:`ReadWriteLock`.
+
+    :param lock_file: path to the SQLite database file used as the lock
+    :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+    :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+    :param is_singleton: if ``True``, reuse existing :class:`ReadWriteLock` instances for the same resolved path
+    :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop
+    :param executor: executor for ``run_in_executor``; ``None`` uses the default executor
+
+    .. versionadded:: 3.21.0
+
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,
+        loop: asyncio.AbstractEventLoop | None = None,
+        executor: futures.Executor | None = None,
+    ) -> None:
+        self._lock = ReadWriteLock(lock_file, timeout, blocking=blocking, is_singleton=is_singleton)
+        self._loop = loop
+        self._executor = executor
+
+    @property
+    def lock_file(self) -> str:
+        """:returns: the path to the lock file."""
+        return self._lock.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """:returns: the default timeout."""
+        return self._lock.timeout
+
+    @property
+    def blocking(self) -> bool:
+        """:returns: whether blocking is enabled by default."""
+        return self._lock.blocking
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop | None:
+        """:returns: the event loop (or ``None`` for the running loop)."""
+        return self._loop
+
+    @property
+    def executor(self) -> futures.Executor | None:
+        """:returns: the executor (or ``None`` for the default)."""
+        return self._executor
+
+    async def _run(self, func: Callable[..., object], *args: object, **kwargs: object) -> object:
+        loop = self._loop or asyncio.get_running_loop()
+        return await loop.run_in_executor(self._executor, functools.partial(func, *args, **kwargs))
+
+    async def acquire_read(self, timeout: float = -1, *, blocking: bool = True) -> AsyncAcquireReadWriteReturnProxy:
+        """
+        Acquire a shared read lock.
+
+        See :meth:`ReadWriteLock.acquire_read` for full semantics.
+
+        :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+
+        :returns: a proxy that can be used as an async context manager to release the lock
+
+        :raises RuntimeError: if a write lock is already held on this instance
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+
+        """
+        await self._run(self._lock.acquire_read, timeout, blocking=blocking)
+        return AsyncAcquireReadWriteReturnProxy(lock=self)
+
+    async def acquire_write(self, timeout: float = -1, *, blocking: bool = True) -> AsyncAcquireReadWriteReturnProxy:
+        """
+        Acquire an exclusive write lock.
+
+        See :meth:`ReadWriteLock.acquire_write` for full semantics.
+
+        :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+
+        :returns: a proxy that can be used as an async context manager to release the lock
+
+        :raises RuntimeError: if a read lock is already held, or a write lock is held by a different thread
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+
+        """
+        await self._run(self._lock.acquire_write, timeout, blocking=blocking)
+        return AsyncAcquireReadWriteReturnProxy(lock=self)
+
+    async def release(self, *, force: bool = False) -> None:
+        """
+        Release one level of the current lock.
+
+        See :meth:`ReadWriteLock.release` for full semantics.
+
+        :param force: if ``True``, release the lock completely regardless of the current lock level
+
+        :raises RuntimeError: if no lock is currently held and *force* is ``False``
+
+        """
+        await self._run(self._lock.release, force=force)
+
+    @asynccontextmanager
+    async def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases a shared read lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        if timeout is None:
+            timeout = self._lock.timeout
+        if blocking is None:
+            blocking = self._lock.blocking
+        await self.acquire_read(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            await self.release()
+
+    @asynccontextmanager
+    async def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases an exclusive write lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        if timeout is None:
+            timeout = self._lock.timeout
+        if blocking is None:
+            blocking = self._lock.blocking
+        await self.acquire_write(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            await self.release()
+
+    async def close(self) -> None:
+        """
+        Release the lock (if held) and close the underlying SQLite connection.
+
+        After calling this method, the lock instance is no longer usable.
+
+        """
+        await self._run(self._lock.close)
+
+
+__all__ = [
+    "AsyncAcquireReadWriteReturnProxy",
+    "AsyncReadWriteLock",
+]

python/x64/py/Lib/site-packages/filelock/_read_write.py

@@ -159,11 +159,12 @@ class ReadWriteLock(metaclass=_ReadWriteLockMeta):
             _all_connections.add(self._con)
 
     def _acquire_transaction_lock(self, *, blocking: bool, timeout: float) -> None:
-        if timeout == -1:
-            # blocking=True with no timeout means wait indefinitely per threading.Lock.acquire semantics
-            acquired = self._transaction_lock.acquire(blocking)
+        if not blocking:
+            acquired = self._transaction_lock.acquire(blocking=False)
+        elif timeout == -1:
+            acquired = self._transaction_lock.acquire(blocking=True)
         else:
-            acquired = self._transaction_lock.acquire(blocking, timeout)
+            acquired = self._transaction_lock.acquire(blocking=True, timeout=timeout)
         if not acquired:
             raise Timeout(self.lock_file) from None
 

python/x64/py/Lib/site-packages/filelock/_soft.py

@@ -54,7 +54,7 @@ class SoftFileLock(BaseFileLock):
             self._context.lock_file_fd = file_handler
 
     def _try_break_stale_lock(self) -> None:
-        with suppress(OSError):
+        with suppress(OSError, ValueError):
             content = Path(self.lock_file).read_text(encoding="utf-8")
             lines = content.strip().splitlines()
             if len(lines) != 2:  # noqa: PLR2004

python/x64/py/Lib/site-packages/filelock/_unix.py

@@ -35,7 +35,13 @@ else:  # pragma: win32 no cover
         has_fcntl = True
 
     class UnixFileLock(BaseFileLock):
-        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+        """
+        Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.
+
+        Lock file cleanup: Unix and macOS delete the lock file reliably after release, even in
+        multi-threaded scenarios. Unlike Windows, Unix allows unlinking files that other processes
+        have open.
+        """
 
         def _acquire(self) -> None:  # noqa: C901, PLR0912
             ensure_directory_exists(self.lock_file)
@@ -100,7 +106,8 @@ else:  # pragma: win32 no cover
             with suppress(OSError):
                 Path(self.lock_file).unlink()
             fcntl.flock(fd, fcntl.LOCK_UN)
-            os.close(fd)
+            with suppress(OSError):  # close can raise EIO on FUSE/Docker bind-mount filesystems after unlink
+                os.close(fd)
 
 
 __all__ = [

python/x64/py/Lib/site-packages/filelock/_windows.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import os
 import sys
+from contextlib import suppress
 from errno import EACCES
+from pathlib import Path
 from typing import cast
 
 from ._api import BaseFileLock
@@ -46,7 +48,13 @@ if sys.platform == "win32":  # pragma: win32 cover
         return bool(attrs & FILE_ATTRIBUTE_REPARSE_POINT)
 
     class WindowsFileLock(BaseFileLock):
-        """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems."""
+        """
+        Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems.
+
+        Lock file cleanup: Windows attempts to delete the lock file after release, but deletion is
+        not guaranteed in multi-threaded scenarios where another thread holds an open handle. The lock
+        file may persist on disk, which does not affect lock correctness.
+        """
 
         def _acquire(self) -> None:
             raise_on_not_writable_file(self.lock_file)
@@ -83,6 +91,9 @@ if sys.platform == "win32":  # pragma: win32 cover
             msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
             os.close(fd)
 
+            with suppress(OSError):
+                Path(self.lock_file).unlink()
+
 else:  # pragma: win32 no cover
 
     class WindowsFileLock(BaseFileLock):

python/x64/py/Lib/site-packages/filelock/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '3.24.3'
-__version_tuple__ = version_tuple = (3, 24, 3)
+__version__ = version = '3.25.2'
+__version_tuple__ = version_tuple = (3, 25, 2)
 
 __commit_id__ = commit_id = None

python/x64/py/Lib/site-packages/pip-26.0.1.dist-info/RECORD

@@ -1,6 +1,6 @@
-../../Scripts/pip.exe,sha256=-AoFiQHnV-ARjUA7PX1X4wYiz1J7WVb-Ac_a12Tlaa0,108384
-../../Scripts/pip3.12.exe,sha256=-AoFiQHnV-ARjUA7PX1X4wYiz1J7WVb-Ac_a12Tlaa0,108384
-../../Scripts/pip3.exe,sha256=-AoFiQHnV-ARjUA7PX1X4wYiz1J7WVb-Ac_a12Tlaa0,108384
+../../Scripts/pip.exe,sha256=AeJuBWfW5zWVXvN2fIwI1QVrFHmEk7pnQ6AKb5vZCck,108381
+../../Scripts/pip3.12.exe,sha256=AeJuBWfW5zWVXvN2fIwI1QVrFHmEk7pnQ6AKb5vZCck,108381
+../../Scripts/pip3.exe,sha256=AeJuBWfW5zWVXvN2fIwI1QVrFHmEk7pnQ6AKb5vZCck,108381
 pip-26.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
 pip-26.0.1.dist-info/METADATA,sha256=ZqIZuNGsG6l2gHiKlQjVQghFQhgSWfhEDHuCVPW3aN8,4675
 pip-26.0.1.dist-info/RECORD,,