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

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

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

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

@@ -101,7 +101,12 @@ def acquire(  # noqa: C901
 
     start = _funcs.utc_now()
 
-    my_writer_id = humenc.encode(uuid4().bytes)
+    my_writer_id = humenc.encode(uuid4().bytes, num_bytes=2)
+    # we do not expect there to be many writers, so we make the humenc part of the writer
+    # id relatively short so it doesn't 'look' like other uses of humenc.  Making the rest
+    # of the string identical to the base64 encoding (by choosing a multiple of 3) is not
+    # useful to us because we are only using this as a big UUID, not as a hash of an
+    # actual input.
 
     lockfile_writer = LockfileWriter(
         my_writer_id,

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

@@ -9,13 +9,15 @@ 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 config, log
+from thds.core import cache, config, log, scope
 
 from ._funcs import make_lock_uri
 from .read import get_writer_id, make_read_lockfile
@@ -23,32 +25,137 @@ 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 _MaintainOnly(ty.NamedTuple):
-    """Matches the LockAcquired interface except that release() will do nothing."""
+class _LockMaintenanceKit(ty.NamedTuple):
+    wakeup_time: float
+    lock_acquired: LockAcquired
+    should_exit: ty.Callable[[], bool]
 
-    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:
-        # maintain the lock twice as often as necessary, to be safe
-        time.sleep(expire_s / 2)
-        if should_exit():
-            return
-        maintain()
+        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.
 
 
 class CannotMaintainLock(ValueError):
@@ -59,9 +166,9 @@ class LockWasStolenError(ValueError):
     pass  # pragma: no cover
 
 
-def remote_lock_maintain(lock_dir_uri: str, expected_writer_id: str = "") -> LockAcquired:
+def make_remote_lock_writer(lock_dir_uri: str, expected_writer_id: str = "") -> LockAcquired:
     """Only for use by remote side - does not _acquire_ the lock,
-    but merely maintains it as unexpired. Does not allow for releasing,
+    but merely allows for it to be maintained 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
@@ -72,7 +179,15 @@ def remote_lock_maintain(lock_dir_uri: str, expected_writer_id: str = "") -> Loc
     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.
 
-    The return value is intended to be launched as the target of a Thread or Process.
+    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.
     """
 
     try:
@@ -115,52 +230,13 @@ def remote_lock_maintain(lock_dir_uri: str, expected_writer_id: str = "") -> Loc
     return lockfile_writer
 
 
-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]:
+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 launch_daemon_lock_maintainer(acquired_lock)
+        return add_lock_to_maintenance_daemon(acquired_lock)
 
     return acquired_lock.release
 

thds/mops/pure/pickling/remote.py

@@ -1,3 +1,4 @@
+import contextlib
 import typing as ty
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -52,9 +53,30 @@ class _ResultExcWithMetadataChannel:
         )
 
     def return_value(self, r: T) -> None:
+        result_uri = self.fs.join(self.call_id, results.RESULT)
+        if self.fs.exists(result_uri):
+            logger.warning("Not overwriting existing result at %s prior to serialization", result_uri)
+            self._write_metadata_only("lost-race")
+            return
+
+        # when we pickle the return value, we also end up potentially uploading
+        # various Sources and Paths and other special-cased things inside the result.
         return_value_bytes = _pickle.gimme_bytes(self.dumper, r)
+        if self.fs.exists(result_uri):
+            logger.warning("Not overwriting existing result at %s after serialization", result_uri)
+            self._write_metadata_only("lost-race-after-serialization")
+            return
+
+        # BUG: there remains a race condition between fs.exists and putbytes.
+        # multiple callers could get a False from fs.exists and then proceed to write.
+        # the biggest issue here is for functions that are not truly pure, because
+        # they will be writing different results, and theoretically different callers
+        # could end up seeing the different results.
+        #
+        # In the future, if a Blob Store provided a put_unless_exists method, we could use
+        # that to avoid the race condition.
         self.fs.putbytes(
-            self.fs.join(self.call_id, results.RESULT),
+            result_uri,
             self._metadata_header + return_value_bytes,
             type_hint="application/mops-return-value",
         )
@@ -79,6 +101,25 @@ 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.
 
@@ -92,16 +133,6 @@ def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
 
     # any recursively-called functions that use metadata will retain the original invoker.
 
-    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.")
-        stop_lock = lambda: None  # noqa: E731
-
     def _extract_invocation_unique_key(memo_uri: str) -> ty.Tuple[str, str]:
         parts = fs.split(memo_uri)
         try:
@@ -113,6 +144,7 @@ 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:
@@ -124,6 +156,14 @@ def run_pickled_invocation(memo_uri: str, *metadata_args: str) -> None:
     def do_work_return_result() -> object:
         # ONLY failures in this code should transmit an EXCEPTION
         # back to the orchestrator side.
+
+        # if the lock was stolen, we will 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
+
         with unwrap_use_runner(func):
             return func(*args, **kwargs)
 
@@ -143,4 +183,3 @@ 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,9 +35,11 @@ _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=" {} ")
 
 
@@ -141,6 +143,8 @@ 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).
@@ -181,17 +185,23 @@ 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:
-            _LogNewInvocation(f"Invoking {memo_uri}")
+            log_invocation(f"Invoking {memo_uri}")
             upload_invocation_and_deps()
 
         # can't hold the semaphore while we block on the shim, though.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thds.mops
-Version: 3.9.20250730184538
+Version: 3.9.20250805191550
 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.20250730184538.dist-info → thds_mops-3.9.20250805191550.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=Fq5Fa9DGFcADFxfyFckSl1mYX7p8DAemjMKH9PMpb-s,240
-thds/mops/pure/core/lock/_acquire.py,sha256=O__mQCUQy0mx-JGNgQjbaSPbfCOXkaiJealYt2Av7Cg,9079
+thds/mops/pure/core/lock/__init__.py,sha256=4x9NdborLPGktDNs8LDapW17LeuAHLCbO9v-8IWdT2I,268
+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=5IUQFAU96p46nNt6SMwTAlB2e0HGHJj8n7kqeRxb26M,5767
+thds/mops/pure/core/lock/maintain.py,sha256=UFhXdr9Q6FdPgq3PtELiAKdlRVl1sqF8IzAf3Oun4g4,9718
 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=l4bIDc7jg7923IFKBeJE3oJYCN4OeT5tmtAg1eS_k7c,6011
+thds/mops/pure/pickling/remote.py,sha256=eax4y0FgoH6id-ceptYbs9_bSLA9TIBhw2EEHqBkvHE,7971
 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=tTRQcglYdf4PC7-smkqJAi-u2BQYR61g21gwrBIcEyY,10406
+thds/mops/pure/runner/local.py,sha256=Qw1g6GasYyWWoZ7ACug8Sq0B__-FoqcaFO7HfFq0rys,11024
 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.20250730184538.dist-info/METADATA,sha256=jLElk3god1pLJ8DSrnW5FUPB72Wgo8ICq6_wjwddF_w,2225
-thds_mops-3.9.20250730184538.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thds_mops-3.9.20250730184538.dist-info/entry_points.txt,sha256=qKvCAaB80syXfxVR3xx6x9J0YJdaQWkIbVSw-NwFgMw,322
-thds_mops-3.9.20250730184538.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_mops-3.9.20250730184538.dist-info/RECORD,,
+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,,