thds.mops 3.9.20250805191550__py3-none-any.whl → 3.9.20250805195442__py3-none-any.whl

thds/mops/pure/core/lock/__init__.py

@@ -2,8 +2,8 @@ from ._acquire import acquire  # noqa: F401
 from .maintain import (  # noqa: F401
     CannotMaintainLock,
     LockWasStolenError,
-    add_lock_to_maintenance_daemon,
+    launch_daemon_lock_maintainer,
     maintain_to_release,
-    make_remote_lock_writer,
+    remote_lock_maintain,
 )
 from .types import LockAcquired  # noqa: F401

thds/mops/pure/core/lock/maintain.py

@@ -9,15 +9,13 @@ it when they get started, and from then on keep the `written_at` timestamp up to
 
 """
 
-import heapq
-import os
-import threading
 import time
 import typing as ty
-from dataclasses import dataclass
 from datetime import datetime, timedelta
+from functools import partial
+from threading import Thread
 
-from thds.core import cache, config, log, scope
+from thds.core import config, log
 
 from ._funcs import make_lock_uri
 from .read import get_writer_id, make_read_lockfile
@@ -25,137 +23,32 @@ from .types import LockAcquired
 from .write import LockEmitter, LockfileWriter
 
 MAINTAIN_LOCKS = config.item("thds.mops.pure.local.maintain_locks", default=True, parse=config.tobool)
-_MAINTENANCE_MARGIN = 0.5  # multiplier for the expire time
-assert _MAINTENANCE_MARGIN < 1, "Maintenance margin must be less than 1 or locks will expire!"
-
-_MAX_LOCKS_PER_THREAD = 200  # I want to leave lots of margin so that locks don't expire.
 
 logger = log.getLogger(__name__)
 
 
-class _LockMaintenanceKit(ty.NamedTuple):
-    wakeup_time: float
-    lock_acquired: LockAcquired
-    should_exit: ty.Callable[[], bool]
+class _MaintainOnly(ty.NamedTuple):
+    """Matches the LockAcquired interface except that release() will do nothing."""
 
+    maintain: ty.Callable[[], None]
+    expire_s: float
+    release: ty.Callable[[], None]
 
-class _LockMaintenanceThreadState(ty.NamedTuple):
-    heap: list[_LockMaintenanceKit]
-    heap_lock: threading.Lock
-    lock_added_event: threading.Event
 
+class _MaintainForever(ty.Protocol):
+    def __call__(self) -> None:
+        ...  # pragma: no cover
 
-@scope.bound
-def _maintenance_daemon(state: _LockMaintenanceThreadState, daemon_num: int) -> None:
-    """Daemon thread that maintains a set of locks."""
-    scope.enter(log.logger_context(pid=os.getpid(), maint_daemon_num=daemon_num))
-    log_at_level = logger.warning if daemon_num > 0 else logger.debug
-    log_at_level("Starting lock maintenance daemon thread %s", daemon_num)
 
+def _maintain_forever(
+    maintain: ty.Callable[[], ty.Any], expire_s: float, should_exit: ty.Callable[[], bool]
+) -> None:
     while True:
-        with state.heap_lock:
-            if not state.heap:
-                next_wakeup_time = None
-            else:
-                next_wakeup_time = state.heap[0].wakeup_time
-
-        if next_wakeup_time is None:
-            logger.debug("No locks to maintain; waiting indefinitely for new ones")
-            state.lock_added_event.wait()
-            state.lock_added_event.clear()
-            continue
-
-        # Wait until either: next maintenance time OR new lock added
-        sleep_duration = max(0, next_wakeup_time - time.monotonic())
-        woke_early = state.lock_added_event.wait(timeout=sleep_duration)
-        state.lock_added_event.clear()
-
-        if woke_early:
-            continue  # go back to the beginning and check for the highest priority lock
-
-        # Time to do maintenance
-        while state.heap and state.heap[0].wakeup_time <= time.monotonic():
-            with state.heap_lock:
-                _, lock_obj, should_exit_fn = heapq.heappop(state.heap)
-
-            if not should_exit_fn():
-                try:
-                    logger.debug("Maintaining lock %s", lock_obj.writer_id)
-                    lock_obj.maintain()
-                    # Re-schedule for next maintenance
-                    with state.heap_lock:
-                        next_maintenance = time.monotonic() + (lock_obj.expire_s * _MAINTENANCE_MARGIN)
-                        heapq.heappush(
-                            state.heap,
-                            _LockMaintenanceKit(next_maintenance, lock_obj, should_exit_fn),
-                        )
-                except Exception:
-                    logger.exception(f"Failed to maintain lock: {lock_obj}")
-
-
-@dataclass
-class _ShouldExit:
-    lock_acquired: LockAcquired
-    should_exit: bool = False
-
-    def check_status(self) -> bool:
-        return self.should_exit
-
-    def stop_maintaining(self) -> None:
-        self.should_exit = True
-        self.lock_acquired.release()
-
-
-_LOCK_RELEASERS_BY_ID = dict[str, ty.Callable[[], None]]()
-_LOCK_MAINTENANCE_DAEMON_STATES = dict[int, _LockMaintenanceThreadState]()
-
-
-@cache.locking
-def _ensure_daemon(thread_num: int) -> None:
-    """Start the maintenance daemon exactly once."""
-    lock_state = _LockMaintenanceThreadState(
-        heap=[],
-        heap_lock=threading.Lock(),
-        lock_added_event=threading.Event(),
-    )
-    assert thread_num not in _LOCK_MAINTENANCE_DAEMON_STATES  # protected by the cache.locking decorator
-    _LOCK_MAINTENANCE_DAEMON_STATES[thread_num] = lock_state
-    threading.Thread(target=_maintenance_daemon, args=(lock_state, thread_num), daemon=True).start()
-
-
-def add_lock_to_maintenance_daemon(lock_acq: LockAcquired) -> ty.Callable[[], None]:
-    """Add lock to global maintenance system and return a cleanup function."""
-    if lock_acq.writer_id in _LOCK_RELEASERS_BY_ID:
-        # technically we could be locking this, but mops itself does not allow
-        # multiple callers to ask for the same lock to be maintained at the same time;
-        # it will always be either the runner or the future that the runner has created.
-        return _LOCK_RELEASERS_BY_ID[lock_acq.writer_id]
-
-    should_exit = _ShouldExit(lock_acq)
-
-    for i in range(len(_LOCK_MAINTENANCE_DAEMON_STATES) + 1):
-        maintenance_daemon_state = _LOCK_MAINTENANCE_DAEMON_STATES.get(i)
-        if maintenance_daemon_state is None:
-            _ensure_daemon(i)
-            maintenance_daemon_state = _LOCK_MAINTENANCE_DAEMON_STATES[i]
-        elif len(maintenance_daemon_state.heap) > _MAX_LOCKS_PER_THREAD:
-            continue  # go to next thread if this one is too full
-
-        with maintenance_daemon_state.heap_lock:
-            next_time = time.monotonic() + (lock_acq.expire_s * _MAINTENANCE_MARGIN)
-            heapq.heappush(
-                maintenance_daemon_state.heap,
-                _LockMaintenanceKit(next_time, lock_acq, should_exit.check_status),
-            )
-        maintenance_daemon_state.lock_added_event.set()
-        break  # we found a thread that can take the lock
-
-    _LOCK_RELEASERS_BY_ID[lock_acq.writer_id] = should_exit.stop_maintaining
-    return should_exit.stop_maintaining
-
-
-# from this point down, the code is about how to prepare to call add_lock_to_maintenance_daemon
-# from the remote side, and what happens if the lock cannot or should not be maintained.
+        # maintain the lock twice as often as necessary, to be safe
+        time.sleep(expire_s / 2)
+        if should_exit():
+            return
+        maintain()
 
 
 class CannotMaintainLock(ValueError):
@@ -166,9 +59,9 @@ class LockWasStolenError(ValueError):
     pass  # pragma: no cover
 
 
-def make_remote_lock_writer(lock_dir_uri: str, expected_writer_id: str = "") -> LockAcquired:
+def remote_lock_maintain(lock_dir_uri: str, expected_writer_id: str = "") -> LockAcquired:
     """Only for use by remote side - does not _acquire_ the lock,
-    but merely allows for it to be maintained as unexpired. Does not allow for releasing,
+    but merely maintains it as unexpired. Does not allow for releasing,
     as it is not the responsibility of the remote side to release the lock.
 
     Will raise a CannotMaintainLock exception if the lock does not exist or has no
@@ -179,15 +72,7 @@ def make_remote_lock_writer(lock_dir_uri: str, expected_writer_id: str = "") ->
     match the lock's actual current writer_id - in other words, if some other writer has
     acquired the lock before the remote side has been able to start running.
 
-    Notably, this is a race condition! The remote side depends on actual lock holders to
-    cooperate in having only a single lock holder; the remote is simply checking a single
-    time and then maintaining the lock indefinitely if the writer_id matches.
-
-    TODO: If the lock is already expired but the writer_id still matches, perhaps we
-    could be acquiring the lock to eliminate the race, and if we fail, we would
-    exit with LockWasStolenError...
-
-    The return value is intended to be passed to add_lock_to_maintenance_daemon.
+    The return value is intended to be launched as the target of a Thread or Process.
     """
 
     try:
@@ -230,13 +115,52 @@ def make_remote_lock_writer(lock_dir_uri: str, expected_writer_id: str = "") ->
     return lockfile_writer
 
 
-def maintain_to_release(acquired_lock: LockAcquired) -> ty.Callable[[], None]:
+def launch_daemon_lock_maintainer(lock_acq: LockAcquired) -> ty.Callable[[], None]:
+    """Run lock maintenance until the process exits, or until the returned callable gets
+    returned.
+
+    Return a 'release wrapper' that stops maintenance of the lock and releases it.
+
+    A whole thread for this seems expensive, but the simplest alternative is having too
+    many lock maintainers trying to share time slices within some global lock maintainer,
+    and that runs a definite risk of overrunning the expiry time(s) for those locks.
+
+    If we were async all the way down, we could more plausibly make a bunch of async
+    network/filesystem calls here without taking into consideration how long they actually
+    take to execute.
+    """
+    should_exit = False
+
+    def should_stop_maintaining() -> bool:
+        return should_exit
+
+    Thread(
+        target=partial(
+            _maintain_forever,
+            lock_acq.maintain,
+            lock_acq.expire_s,
+            should_stop_maintaining,
+        ),
+        daemon=True,
+    ).start()
+
+    def stop_maintaining() -> None:
+        nonlocal should_exit
+        should_exit = True
+        lock_acq.release()
+
+    return stop_maintaining
+
+
+def maintain_to_release(
+    acquired_lock: LockAcquired,
+) -> ty.Callable[[], None]:
     """Depending on configuration, potentially start maintaining the lock.
 
     Return a callable that will release the lock when called.
     """
     if MAINTAIN_LOCKS():
-        return add_lock_to_maintenance_daemon(acquired_lock)
+        return launch_daemon_lock_maintainer(acquired_lock)
 
     return acquired_lock.release
 

thds/mops/pure/pickling/remote.py

@@ -1,4 +1,3 @@
-import contextlib
 import typing as ty
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -101,25 +100,6 @@ def _unpickle_invocation(memo_uri: str) -> ty.Tuple[ty.Callable, Args, Kwargs]:
     return invocation.func, args, kwargs
 
 
-@contextlib.contextmanager
-def _manage_lock(lock_uri: str, lock_writer_id: str) -> ty.Iterator[ty.Optional[Exception]]:
-    stop_lock: ty.Callable = lambda: None  # noqa: E731
-    try:
-        stop_lock = lock.add_lock_to_maintenance_daemon(
-            lock.make_remote_lock_writer(lock_uri, expected_writer_id=lock_writer_id)
-        )
-        yield None  # pause for execution
-    except lock.CannotMaintainLock as e:
-        logger.info(f"Cannot maintain lock: {e}. Continuing without the lock.")
-        yield None  # pause for execution
-    except lock.LockWasStolenError as stolen_lock_error:
-        logger.error(f"Lock was stolen: {stolen_lock_error}. Will exit without running the function.")
-        yield stolen_lock_error  # pause to upload failure
-
-    stop_lock()  # not critical since we don't _own_ the lock, but keeps things cleaner
-
-
-@scope.bound
 def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
     """The arguments are those supplied by MemoizingPicklingRunner.
 
@@ -133,6 +113,20 @@ def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
 
     # any recursively-called functions that use metadata will retain the original invoker.
 
+    failure_to_lock = None
+    stop_lock: ty.Callable = lambda: None  # noqa: E731
+    try:
+        stop_lock = lock.launch_daemon_lock_maintainer(
+            lock.remote_lock_maintain(
+                fs.join(memo_uri, "lock"), expected_writer_id=invocation_metadata.invoker_uuid
+            )
+        )
+    except lock.CannotMaintainLock as e:
+        logger.info(f"Cannot maintain lock: {e}. Continuing without the lock.")
+    except lock.LockWasStolenError as e:
+        logger.error(f"Lock was stolen: {e}. Exiting without running the function.")
+        failure_to_lock = e
+
     def _extract_invocation_unique_key(memo_uri: str) -> ty.Tuple[str, str]:
         parts = fs.split(memo_uri)
         try:
@@ -144,7 +138,6 @@ def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
         invocation_parts = parts[runner_idx + 1 :]
         return fs.join(*invocation_parts[:-1]), invocation_parts[-1]
 
-    lock_error = scope.enter(_manage_lock(fs.join(memo_uri, "lock"), invocation_metadata.invoker_uuid))
     scope.enter(uris.ACTIVE_STORAGE_ROOT.set(uris.get_root(memo_uri)))
 
     try:
@@ -157,12 +150,12 @@ def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
         # ONLY failures in this code should transmit an EXCEPTION
         # back to the orchestrator side.
 
-        # if the lock was stolen, we will write an exception
+        # if the lock was stolen, we should write an exception
         # so that the orchestrator knows that it failed.
         # in theory, it could resume waiting for a result, though
         # currently it does not do this.
-        if lock_error:
-            raise lock_error
+        if failure_to_lock:
+            raise failure_to_lock
 
         with unwrap_use_runner(func):
             return func(*args, **kwargs)
@@ -183,3 +176,4 @@ def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
         invocation_metadata.pipeline_id,
         _extract_invocation_unique_key(memo_uri),
     )
+    stop_lock()  # not critical since we don't _own_ the lock, but keeps things cleaner

thds/mops/pure/runner/local.py

@@ -35,11 +35,9 @@ _BEFORE_INVOCATION_SEMAPHORE = threading.BoundedSemaphore(int(max_concurrent_net
 _DarkBlue = colorized(fg="white", bg="#00008b")
 _GreenYellow = colorized(fg="black", bg="#adff2f")
 _Purple = colorized(fg="white", bg="#800080")
-_Pink = colorized(fg="black", bg="#ff1493")
 logger = log.getLogger(__name__)
 _LogKnownResult = make_colorized_out(_DarkBlue, out=logger.info, fmt_str=" {} ")
 _LogNewInvocation = make_colorized_out(_GreenYellow, out=logger.info, fmt_str=" {} ")
-_LogInvocationAfterSteal = make_colorized_out(_Pink, out=logger.info, fmt_str=" {} ")
 _LogAwaitedResult = make_colorized_out(_Purple, out=logger.info, fmt_str=" {} ")
 
 
@@ -143,8 +141,6 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
             run_summary.extract_source_uris((args, kwargs)),
         )
 
-        log_invocation = _LogNewInvocation  # this is what we use unless we steal the lock.
-
         # the network ops being grouped by _BEFORE_INVOCATION include one or more
         # download attempts (consider possible Paths) plus
         # one or more uploads (embedded Paths & Sources/refs, and then invocation).
@@ -185,23 +181,17 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
                     return futures.resolved(p_unwrap_value_or_error(memo_uri, result))
 
                 lock_owned = acquire_lock()  # still inside the semaphore, as it's a network op
-                if lock_owned:
-                    log_invocation = _LogInvocationAfterSteal
-                    logger.info(f"Stole expired lock for {memo_uri} - invoking ourselves.")
 
         assert lock_owned is not None
         # if/when we acquire the lock, we move forever into 'run this ourselves mode'.
         # If something about our invocation fails,
         # we fail just as we would have previously, without any attempt to go
         # 'back' to waiting for someone else to compute the result.
-        lock.maintain_to_release(lock_owned)
-        # we don't actually need the release_lock here, because it will get
-        # 'recreated' in the PostShimResultGetter below, which is also where it gets called
 
         future_result_getter = PostShimResultGetter[T](memo_uri, p_unwrap_value_or_error)
 
         with _BEFORE_INVOCATION_SEMAPHORE:
-            log_invocation(f"Invoking {memo_uri}")
+            _LogNewInvocation(f"Invoking {memo_uri}")
             upload_invocation_and_deps()
 
         # can't hold the semaphore while we block on the shim, though.

{thds_mops-3.9.20250805191550.dist-info → thds_mops-3.9.20250805195442.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thds.mops
-Version: 3.9.20250805191550
+Version: 3.9.20250805195442
 Summary: ML Ops tools for Trilliant Health
 Author-email: Trilliant Health <info@trillianthealth.com>
 Project-URL: Repository, https://github.com/TrilliantHealth/ds-monorepo

{thds_mops-3.9.20250805191550.dist-info → thds_mops-3.9.20250805195442.dist-info}/RECORD

@@ -66,11 +66,11 @@ thds/mops/pure/core/entry/__init__.py,sha256=kiDcsj16CwjRSexOZW-4h4b4tDCYIS_eLS5
 thds/mops/pure/core/entry/main.py,sha256=b1F5lFDK_hnpvW3bqzt5MWDcpKvCXZpWdEHI8zroC4k,2061
 thds/mops/pure/core/entry/route_result.py,sha256=2LcS9M2mYtu56kso0YcMEZbR1mbTWZm0hFlbE2yaf4k,2741
 thds/mops/pure/core/entry/runner_registry.py,sha256=aPDCML7gM_zP6NfPnqx0_Q1oRHzgdaCa_XzYc5VIw7U,601
-thds/mops/pure/core/lock/__init__.py,sha256=4x9NdborLPGktDNs8LDapW17LeuAHLCbO9v-8IWdT2I,268
+thds/mops/pure/core/lock/__init__.py,sha256=MVwbqK-tQX-Y20lhmofLHFoyEgkQGsaKa9a9JgCP4jc,264
 thds/mops/pure/core/lock/_acquire.py,sha256=lVxHzDA30VB95Cfb4Fl2m0eatdLXCDv6rOCnERiyMNw,9468
 thds/mops/pure/core/lock/_funcs.py,sha256=j4g8yVWnrAMPDKqLlq8nTnccM1KHSJ3g71L1iWNbV2Q,969
 thds/mops/pure/core/lock/cli.py,sha256=uidtmgHB2y5LDkj7SQTncy_cNe1EfIseuiJPV9kcxBU,2488
-thds/mops/pure/core/lock/maintain.py,sha256=UFhXdr9Q6FdPgq3PtELiAKdlRVl1sqF8IzAf3Oun4g4,9718
+thds/mops/pure/core/lock/maintain.py,sha256=5IUQFAU96p46nNt6SMwTAlB2e0HGHJj8n7kqeRxb26M,5767
 thds/mops/pure/core/lock/read.py,sha256=Ct5eYMlkTlEaV5Yhw6HWsDD7VrgdhDZoI6AVIQ0ts-4,1255
 thds/mops/pure/core/lock/types.py,sha256=f32t_e2svMOXUVzcnLkEizw6Q47g3HPQsyAkGT2OKMs,993
 thds/mops/pure/core/lock/write.py,sha256=yuF2zRAzgYOmnet1GXZHwYT7oT1znVB3SPK1_j7orFA,5556
@@ -89,11 +89,11 @@ thds/mops/pure/pickling/_pickle.py,sha256=YB8xbqDiwdk8ccnVZ2_4kQn98V2JSrFqw2E3J-
 thds/mops/pure/pickling/memoize_only.py,sha256=oI5CMy6IEJc46Gb_BGWNUuAe3fysS7HxRSTajN0WssI,837
 thds/mops/pure/pickling/mprunner.py,sha256=vabdHIVteddkU5ncOq73wWC7-naChW_3_vvAQArvjqU,8814
 thds/mops/pure/pickling/pickles.py,sha256=CSlnjLssE0Ad8YzqyaKqWCSNyW5LiMFKiXO6hWAZmvU,5097
-thds/mops/pure/pickling/remote.py,sha256=eax4y0FgoH6id-ceptYbs9_bSLA9TIBhw2EEHqBkvHE,7971
+thds/mops/pure/pickling/remote.py,sha256=i2fD9WMuk3rqNxqnQWvkSw9lW6eXVdQ1laxXQWEB3hQ,7665
 thds/mops/pure/pickling/sha256_b64.py,sha256=HL0cPixHPZYuZDVDBscxsnI-3a2amWEfw-LseOX-PyY,2916
 thds/mops/pure/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/pure/runner/get_results.py,sha256=1K6qf_Vg2YfUPfUuu103WyYsfS3e_ju6W7Z_PV01-pU,4053
-thds/mops/pure/runner/local.py,sha256=Qw1g6GasYyWWoZ7ACug8Sq0B__-FoqcaFO7HfFq0rys,11024
+thds/mops/pure/runner/local.py,sha256=tTRQcglYdf4PC7-smkqJAi-u2BQYR61g21gwrBIcEyY,10406
 thds/mops/pure/runner/shim_builder.py,sha256=obs2-NipAB8w0NR8o90UQX_bmHYS69c-raL2JPw8yM4,821
 thds/mops/pure/runner/simple_shims.py,sha256=r-kLmpSCwzjfzF-Ku43YKvrHMLpZR5jDmweo4Vk07O4,1069
 thds/mops/pure/runner/strings.py,sha256=PYAYMxZ2ehgahKIBXJilENNE6OrdNkueNBel8LPsoh8,26
@@ -109,8 +109,8 @@ thds/mops/pure/tools/summarize/cli.py,sha256=7kDtn24ok8oBO3jFjlMmOK3jnZYpMoE_5Y8
 thds/mops/pure/tools/summarize/run_summary.py,sha256=w45qiQr7elrHDiK9Hgs85gtU3gwLuXa447ih1Y23BBY,5776
 thds/mops/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/testing/deferred_imports.py,sha256=f0ezCgQAtzTqW1yAOb0OWgsB9ZrlztLB894LtpWDaVw,3780
-thds_mops-3.9.20250805191550.dist-info/METADATA,sha256=fNmRhdaq6BzlVyZzEZIHeu6nCIgYBgHuGjUZbcSZR9I,2225
-thds_mops-3.9.20250805191550.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thds_mops-3.9.20250805191550.dist-info/entry_points.txt,sha256=qKvCAaB80syXfxVR3xx6x9J0YJdaQWkIbVSw-NwFgMw,322
-thds_mops-3.9.20250805191550.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_mops-3.9.20250805191550.dist-info/RECORD,,
+thds_mops-3.9.20250805195442.dist-info/METADATA,sha256=dEvgXJoq3NhuzjbnH6kTyvSjMwlmyljRxKZziy2QH7A,2225
+thds_mops-3.9.20250805195442.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thds_mops-3.9.20250805195442.dist-info/entry_points.txt,sha256=qKvCAaB80syXfxVR3xx6x9J0YJdaQWkIbVSw-NwFgMw,322
+thds_mops-3.9.20250805195442.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds_mops-3.9.20250805195442.dist-info/RECORD,,