thds.mops 3.9.20250722200009__py3-none-any.whl → 3.9.20250722213952__py3-none-any.whl

thds/mops/pure/runner/local.py

@@ -5,32 +5,28 @@ import threading
 import time
 import typing as ty
 from datetime import datetime, timedelta, timezone
-from functools import partial
 from pathlib import Path
 
-from thds.core import futures, log, scope
+from thds.core import config, log, scope
 from thds.termtool.colorize import colorized, make_colorized_out
 
 from ...config import max_concurrent_network_ops
 from ..core import deferred_work, lock, memo, metadata, pipeline_id_mask, uris
-from ..core.lock.maintain import MAINTAIN_LOCKS  # noqa: F401
 from ..core.partial import unwrap_partial
-from ..core.types import Args, Kwargs, T
+from ..core.types import Args, Kwargs, NoResultAfterShimSuccess, T
 from ..tools.summarize import run_summary
 from . import strings, types
-from .get_results import (
-    PostShimResultGetter,
-    ResultAndInvocationType,
-    lock_maintaining_future,
-    unwrap_value_or_error,
-)
-
-# this semaphore (and a similar one in get_results) allow us to prioritize getting a single unit
+
+MAINTAIN_LOCKS = config.item("thds.mops.pure.local.maintain_locks", default=True, parse=config.tobool)
+
+# these two semaphores allow us to prioritize getting meaningful units
 # of progress _complete_, rather than issuing many instructions to the
 # underlying client and allowing it to randomly order the operations
 # such that it takes longer to get a full unit of work complete.
 _BEFORE_INVOCATION_SEMAPHORE = threading.BoundedSemaphore(int(max_concurrent_network_ops()))
-# _BEFORE prioritizes uploading a single invocation and its dependencies so the Shim can start running.
+# _OUT prioritizes uploading a single invocation and its dependencies so the Shim can start running.
+_AFTER_INVOCATION_SEMAPHORE = threading.BoundedSemaphore(int(max_concurrent_network_ops()))
+# _IN prioritizes retrieving the result of a Shim that has completed.
 
 _DarkBlue = colorized(fg="white", bg="#00008b")
 _GreenYellow = colorized(fg="black", bg="#adff2f")
@@ -48,9 +44,9 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
     get_meta_and_result: types.GetMetaAndResult,
     run_directory: ty.Optional[Path] = None,
     calls_registry: ty.Mapping[ty.Callable, ty.Collection[ty.Callable]] = dict(),  # noqa: B006
-) -> ty.Callable[[bool, str, ty.Callable[..., T], Args, Kwargs], futures.PFuture[T]]:
+) -> ty.Callable[[bool, str, ty.Callable[..., T], Args, Kwargs], T]:
     @scope.bound
-    def create_invocation_and_result_future(
+    def create_invocation__check_result__wait_shim(
         rerun_exceptions: bool,
         function_memospace: str,
         # by allowing the caller to set the function memospace, we allow 'redirects' to look up an old result by name.
@@ -58,7 +54,7 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
         func: ty.Callable[..., T],
         args_: Args,
         kwargs_: Kwargs,
-    ) -> futures.PFuture[T]:
+    ) -> T:
         """This is the generic local runner. Its core abstractions are:
 
         - serializers of some sort (for the function and its arguments)
@@ -93,13 +89,16 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
         )
 
         # Define some important and reusable 'chunks of work'
-        def check_result_exists(
+
+        class ResultAndInvocationType(ty.NamedTuple):
+            value_or_error: ty.Union[memo.results.Success, memo.results.Error]
+            invoc_type: run_summary.InvocationType
+
+        def check_result(
             invoc_type: run_summary.InvocationType,
         ) -> ty.Union[ResultAndInvocationType, None]:
             result = memo.results.check_if_result_exists(
-                memo_uri,
-                check_for_exception=not rerun_exceptions,
-                before_raise=debug_required_result_failure,
+                memo_uri, rerun_excs=rerun_exceptions, before_raise=debug_required_result_failure
             )
             if not result:
                 return None
@@ -109,6 +108,28 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
             )
             return ResultAndInvocationType(result, invoc_type)
 
+        def unwrap_value_or_error(result_and_itype: ResultAndInvocationType) -> T:
+            result = result_and_itype.value_or_error
+            metadata = None
+            value_t = None
+            try:
+                if isinstance(result, memo.results.Success):
+                    metadata, value_t = get_meta_and_result("value", result.value_uri)
+                    return ty.cast(T, value_t)
+                else:
+                    assert isinstance(result, memo.results.Error), "Must be Error or Success"
+                    metadata, exc = get_meta_and_result("EXCEPTION", result.exception_uri)
+                    raise exc
+            finally:
+                run_summary.log_function_execution(
+                    *(run_directory, memo_uri, result_and_itype.invoc_type),
+                    metadata=metadata,
+                    runner_prefix=function_memospace.split(pipeline_id)[0],
+                    was_error=not isinstance(result, memo.results.Success),
+                    return_value=value_t,
+                    args_kwargs=(args, kwargs),
+                )
+
         def acquire_lock() -> ty.Optional[lock.LockAcquired]:
             return lock.acquire(fs.join(memo_uri, "lock"), expire=timedelta(seconds=88))
 
@@ -133,14 +154,6 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
 
             inspect_and_log(memo_uri)
 
-        p_unwrap_value_or_error = partial(
-            unwrap_value_or_error,
-            get_meta_and_result,
-            run_directory,
-            function_memospace.split(pipeline_id)[0],  # runner_prefix
-            run_summary.extract_source_uris((args, kwargs)),
-        )
-
         # 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).
@@ -149,9 +162,9 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
 
             # it's possible that our result may already exist from a previous run of this pipeline id.
             # we can short-circuit the entire process by looking for that result and returning it immediately.
-            result = check_result_exists("memoized")
+            result = check_result("memoized")
             if result:
-                return futures.resolved(p_unwrap_value_or_error(memo_uri, result))
+                return unwrap_value_or_error(result)
 
             lock_owned = acquire_lock()
             # if no result exists, the vastly most common outcome here will be acquiring
@@ -162,6 +175,10 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
         # LOCK LOOP: entering this loop (where we attempt to acquire the lock) is the common non-memoized case
         while not result:
             if lock_owned:
+                if MAINTAIN_LOCKS():
+                    release_lock = lock.launch_daemon_lock_maintainer(lock_owned)
+                else:
+                    release_lock = lock_owned.release
                 break  # we own the invocation - invoke the shim ourselves (below)
 
             # getting to this point ONLY happens if we failed to acquire the lock, which
@@ -173,45 +190,57 @@ def invoke_via_shim_or_return_memoized(  # noqa: C901
             time.sleep(22)
 
             with _BEFORE_INVOCATION_SEMAPHORE:
-                result = check_result_exists("awaited")
+                result = check_result("awaited")
                 if result:
                     _LogAwaitedResult(
                         f"{val_or_res} for {memo_uri} was found after waiting for the lock."
                     )
-                    return futures.resolved(p_unwrap_value_or_error(memo_uri, result))
+                    return unwrap_value_or_error(result)
 
                 lock_owned = acquire_lock()  # still inside the semaphore, as it's a network op
 
+        assert release_lock is not None
         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.
 
-        future_result_getter = PostShimResultGetter[T](memo_uri, p_unwrap_value_or_error)
-
-        with _BEFORE_INVOCATION_SEMAPHORE:
-            _LogNewInvocation(f"Invoking {memo_uri}")
-            upload_invocation_and_deps()
-
-        # can't hold the semaphore while we block on the shim, though.
-        shim = shim_builder(func, args_, kwargs_)
-        future_or_shim_result = shim(  # ACTUAL INVOCATION (handoff to remote shim) HAPPENS HERE
-            (
-                memo_uri,
-                *metadata.format_invocation_cli_args(
-                    metadata.InvocationMetadata.new(pipeline_id, invoked_at, lock_owned.writer_id)
-                ),
-            )
-        )
-        if hasattr(future_or_shim_result, "add_done_callback"):
-            # if the shim returns a Future, we wrap it.
-            logger.debug("Shim returned a Future; wrapping it for post-shim result retrieval.")
-            return futures.make_lazy(lock_maintaining_future)(
-                lock_owned, future_result_getter, future_or_shim_result
+        try:
+            with _BEFORE_INVOCATION_SEMAPHORE:
+                _LogNewInvocation(f"Invoking {memo_uri}")
+                upload_invocation_and_deps()
+
+            # can't hold the semaphore while we block on the shim, though.
+            shim_ex = None
+            shim = shim_builder(func, args_, kwargs_)
+            shim(  # ACTUAL INVOCATION (handoff to remote shim) HAPPENS HERE
+                (
+                    memo_uri,
+                    *metadata.format_invocation_cli_args(
+                        metadata.InvocationMetadata.new(pipeline_id, invoked_at, lock_owned.writer_id)
+                    ),
+                )
             )
-        else:  # it's a synchronous shim - just process the result directly.
-            future_result_getter.release_lock = lock.maintain_to_release(lock_owned)
-            return futures.resolved(future_result_getter(future_or_shim_result))
-
-    return create_invocation_and_result_future
+        except Exception as ex:
+            # network or similar errors are very common and hard to completely eliminate.
+            # We know that if a result (or error) exists, then the network failure is
+            # not important, because results in blob storage are atomically populated (either fully there or not)
+            logger.exception("Error awaiting shim. Optimistically checking for result.")
+            shim_ex = ex
+
+        finally:
+            release_lock()
+
+        # the network ops being grouped by _AFTER_INVOCATION include one or more downloads.
+        with _AFTER_INVOCATION_SEMAPHORE:
+            value_or_error = memo.results.check_if_result_exists(memo_uri)
+            if not value_or_error:
+                if shim_ex:
+                    raise shim_ex  # re-raise the underlying exception rather than making up our own.
+                raise NoResultAfterShimSuccess(
+                    f"The shim for {memo_uri} exited cleanly, but no result or exception was found."
+                )
+            return unwrap_value_or_error(ResultAndInvocationType(value_or_error, "invoked"))
+
+    return create_invocation__check_result__wait_shim

thds/mops/pure/runner/shim_builder.py

@@ -2,24 +2,24 @@ import inspect
 import typing as ty
 
 from ..core.types import Args, F, Kwargs
-from .types import FutureShim, Shim, ShimBuilder
+from .types import Shim, ShimBuilder
 
 
 class _static_shim_builder:
-    def __init__(self, shim: ty.Union[Shim, FutureShim]) -> None:
+    def __init__(self, shim: Shim) -> None:
         self.shim = shim
 
-    def __call__(self, _f: F, _args: Args, _kwargs: Kwargs) -> ty.Union[Shim, FutureShim]:
+    def __call__(self, _f: F, _args: Args, _kwargs: Kwargs) -> Shim:
         return self.shim
 
     def __repr__(self) -> str:
         return f"<static_shim_builder for {self.shim}>"
 
 
-def make_builder(shim_or_builder: ty.Union[Shim, ShimBuilder, FutureShim]) -> ShimBuilder:
+def make_builder(shim: ty.Union[Shim, ShimBuilder]) -> ShimBuilder:
     """If you have a Shim and you want to make it into the simplest possible ShimBuilder."""
 
-    if len(inspect.signature(shim_or_builder).parameters) == 3:
-        return ty.cast(ShimBuilder, shim_or_builder)
+    if len(inspect.signature(shim).parameters) == 3:
+        return ty.cast(ShimBuilder, shim)
 
-    return _static_shim_builder(ty.cast(Shim, shim_or_builder))
+    return _static_shim_builder(ty.cast(Shim, shim))

thds/mops/pure/runner/simple_shims.py

@@ -1,4 +1,3 @@
-import concurrent.futures
 import subprocess
 from typing import Sequence
 
@@ -20,9 +19,3 @@ def samethread_shim(shim_args: Sequence[str]) -> None:
 def subprocess_shim(shim_args: Sequence[str]) -> None:
     logger.debug("Running a mops function locally in a new subprocess.")
     subprocess.check_call(["python", "-m", "thds.mops.pure.core.entry.main", *shim_args])
-
-
-def future_subprocess_shim(shim_args: Sequence[str]) -> concurrent.futures.Future:
-    """Use this if you really want a Future rather than just running the process"""
-    logger.debug("Running a mops function in a new subprocess, returning a Future.")
-    return concurrent.futures.ProcessPoolExecutor().submit(samethread_shim, shim_args)

thds/mops/pure/runner/types.py

@@ -1,36 +1,25 @@
 import typing as ty
 
-from thds.core import futures
-
 from ..core.metadata import ResultMetadata
 from ..core.types import Args, F, Kwargs
 
-FutureShim = ty.Callable[[ty.Sequence[str]], futures.PFuture]
-SyncShim = ty.Callable[[ty.Sequence[str]], None]
-Shim = ty.Union[SyncShim, FutureShim]
+Shim = ty.Callable[[ty.Sequence[str]], ty.Any]
 """A runner Shim is a way of getting back into a Python process with enough
 context to download the uploaded function and its arguments from the
 location where a runner placed it, and then invoke the function. All
 arguments are strings because it is assumed that this represents some
 kind of command line invocation.
 
-A SyncShim must be a blocking call, and its result(s) must be available
+The Shim must be a blocking call, and its result(s) must be available
 immediately after its return.
-A FutureShim must return a Future (with an 'add_done_callback' method)
-that, when resolved, means that the result(s) are available.
 """
 
-S = ty.TypeVar("S", SyncShim, FutureShim, Shim, covariant=True)
-
 
-class ShimBuilder(ty.Protocol, ty.Generic[S]):
-    def __call__(self, __f: ty.Callable, __args: Args, __kwargs: Kwargs) -> S:
+class ShimBuilder(ty.Protocol):
+    def __call__(self, __f: F, __args: Args, __kwargs: Kwargs) -> Shim:
         ...  # pragma: no cover
 
 
-SyncShimBuilder = ShimBuilder[SyncShim]
-FutureShimBuilder = ShimBuilder[FutureShim]
-
 StorageRootURI = str
 SerializeArgsKwargs = ty.Callable[[StorageRootURI, F, Args, Kwargs], bytes]
 SerializeInvocation = ty.Callable[[StorageRootURI, F, bytes], bytes]

thds/mops/pure/tools/summarize/run_summary.py

@@ -78,7 +78,7 @@ def _generate_log_filename(
     return run_directory / filename
 
 
-def extract_source_uris(obj: ty.Any) -> ty.Set[str]:
+def _extract_source_uris(result: ty.Any) -> ty.Set[str]:
     uris: ty.Set[str] = set()
 
     def extract_uri(unknown: ty.Any) -> None:
@@ -94,16 +94,15 @@ def extract_source_uris(obj: ty.Any) -> ty.Set[str]:
             material = unknown.material
             if callable(material):
                 mat = material()
-                # recurse!
-                for uri in extract_source_uris(mat):
+                for uri in _extract_source_uris(mat):
                     uris.add(uri)
 
     try:
-        pickle_visit.recursive_visit(extract_uri, obj)
+        pickle_visit.recursive_visit(extract_uri, result)
     except pickle.PicklingError:
         pass
     except Exception as exc:
-        logger.warning(f'Unexpected error trying to extract URIs from "%s"; {exc}', obj)
+        logger.warning(f'Unexpected error trying to extract URIs from "%s"; {exc}', result)
 
     return uris
 
@@ -116,7 +115,7 @@ def log_function_execution(
     runner_prefix: str = "",
     was_error: bool = False,
     return_value: ty.Any = None,
-    args_kwargs_uris: ty.Collection[str] = (),
+    args_kwargs: ty.Any = None,
 ) -> None:
     if not run_directory:
         logger.debug("Not writing function summary for %s", memo_uri)
@@ -146,9 +145,9 @@ def log_function_execution(
         log_entry["remote_code_version"] = metadata.remote_code_version
         # we don't bother with invoked_at or remote_started_at because they can be
         # inferred from the timestamp and the wall times
-    if args_kwargs_uris:
-        log_entry["uris_in_args_kwargs"] = sorted(args_kwargs_uris)
-    if source_uris := extract_source_uris(return_value):
+    if source_uris := _extract_source_uris(args_kwargs):
+        log_entry["uris_in_args_kwargs"] = sorted(source_uris)
+    if source_uris := _extract_source_uris(return_value):
         log_entry["uris_in_rvalue"] = sorted(source_uris)
 
     try:

{thds_mops-3.9.20250722200009.dist-info → thds_mops-3.9.20250722213952.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thds.mops
-Version: 3.9.20250722200009
+Version: 3.9.20250722213952
 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.20250722200009.dist-info → thds_mops-3.9.20250722213952.dist-info}/RECORD

@@ -14,41 +14,37 @@ thds/mops/_utils/once.py,sha256=_LHkPbMJO4nqp0RIDj8VgIV3JoZYSQYKGdatdnT-19s,946
 thds/mops/_utils/temp.py,sha256=pcHkqIPghPfcZcwAFjCIzLfUWdIgXD3XC8Au1dk5l1k,948
 thds/mops/impure/__init__.py,sha256=VnrHPVgbOYUjkrVnnVicvNV39G6K6ENcWtCuV-BedW4,83
 thds/mops/impure/keyfunc.py,sha256=-THL-GPa6j1zjiHBONkiFzKHuOvE_kGdIVtz0nG4Mp8,524
-thds/mops/impure/runner.py,sha256=UI1NZWMZ_5TQHfFKLnoiSm2zDR3zCunTKFmJoybkyCo,2840
-thds/mops/k8s/__init__.py,sha256=zl4GVcCFRvPscyo6gvv5Lx0OKB7d3QjtVFjYurnxMuE,764
-thds/mops/k8s/_launch.py,sha256=n4a3v6JNjcShFlBgRyL6JdS9My0ApggsjurtZFuKOnk,10893
+thds/mops/impure/runner.py,sha256=kaBHDLn64FEg_INVwD9_uZk809qyCJyYK8RaYbVUisY,2812
+thds/mops/k8s/__init__.py,sha256=y4bvR5DQLiriBV0I8CZoQdNlNrXWQ2VpcxY5lOrdnzU,669
 thds/mops/k8s/_shared.py,sha256=MR-s6ijWUHZGjxK_fsOpHuRDB6kuofjo5xiIb7ul2VM,86
 thds/mops/k8s/apply_yaml.py,sha256=hVW6dIVbNdzHdbGlc2VAPGkdByv_rH2oPybyIm7tKIM,820
 thds/mops/k8s/auth.py,sha256=mXFPZvyJYEPASsBatv1r8syB9AoayuHGptHHnNUg8LE,1517
-thds/mops/k8s/batching.py,sha256=VJw6DhdhklOSu-iUW6r_BpAP7Jx62uoKV2Bpy0V9U_Q,8266
-thds/mops/k8s/config.py,sha256=_znocX5BW8kfG_Cbq6f3apx5FqSihD7Tmic-SBkVjMQ,2992
+thds/mops/k8s/config.py,sha256=ha8ppDeFnDB2I9tCajiDcfZlamIk73OJe4lzD5buyXU,2993
 thds/mops/k8s/container_registry.py,sha256=qOiGCE4t_tLYgJDGrhKV9KNv48lF_AlwCDHyFgucd2s,539
-thds/mops/k8s/counts.py,sha256=W_gfXScvrEFskPFU9dEkI7V1I5ExXm9t_bUwO52lwtc,580
-thds/mops/k8s/job_future.py,sha256=_wsH5Lh9qdcGqLZsvXYz8vAFgpV_nMYZ5d8dIFJA-eQ,3933
-thds/mops/k8s/jobs.py,sha256=KcHxlPRukubRp_ddOm0tAX4COs7Ppv0mjbEdv4SAjmM,3359
-thds/mops/k8s/logging.py,sha256=m_3Tn0XAFhUHdEicqRKnMzdK_hvSTCB7hsP1mIilKC4,10940
+thds/mops/k8s/jobs.py,sha256=3u0jc5Fnll2ncnmcdTUHlcxJ_KYNK9s66W7r6ez49As,3271
+thds/mops/k8s/launch.py,sha256=EjLblGExh0paElOZWgevZdVzEZie1_4jQo7fKTrE1N0,10489
+thds/mops/k8s/logging.py,sha256=m4XnhxzLqlZa2zOObFhp_zv3juQfqfwcCughChBqcCo,9773
 thds/mops/k8s/namespace.py,sha256=Z6trVTU9WFashto4PqIhTcxu-foOF93W0TpgqCU7WIA,383
 thds/mops/k8s/node_selection.py,sha256=Gy2Jz8IxZblg2LmtGg8-MtKI4RmXz2AMXqFPP8OQyu0,2065
 thds/mops/k8s/retry.py,sha256=JVfP304kItpLs5nrONHE5UWkVWlrFGlV_oFQqhq3zHg,2846
 thds/mops/k8s/too_old_resource_version.py,sha256=S7ltVA-LrxUpQ8Q__AB0nQmezN8Mmnx5oKK62_baAKI,1500
-thds/mops/k8s/uncertain_future.py,sha256=60v9yVlhnCDN_yUv8l4Z4KafR4TsTGxN7dprkGI8pQQ,7152
 thds/mops/k8s/wait_job.py,sha256=_X5lSn-3CE4V-_ra0kF1WtxkAiOgqSom8mU1-0hhMio,2445
 thds/mops/k8s/warn_image_backoff.py,sha256=ls_zLSnRbJjO4ICjq1Rk21EXh190l2dT6nKg-PT8Das,1934
-thds/mops/k8s/watch.py,sha256=iU3sgWEVyjNgVN9HObMoHoQyT8YPrApn4XZlE0sZcLA,14028
+thds/mops/k8s/watch.py,sha256=pLjyJg94QuDYV-CdoEJD7emkrYe5i5kDUTjtUsYSq4w,11425
 thds/mops/k8s/tools/krsync.py,sha256=us7pXX0-bRMwD2oAno7Z6BJcPs6FgaUabHW0STyQJYg,1773
 thds/mops/k8s/tools/krsync.sh,sha256=fWgwkdzWnJeTbzEA_uBiIIi-bNU4nXAYj3dNovyRluU,747
-thds/mops/pure/__init__.py,sha256=3xLimQ2JWdeq1YgPs7bPwlwOspzPRwaR2w2KX7vfJU0,1624
+thds/mops/pure/__init__.py,sha256=kbG0lMvXRBS3LGbb2gPPE9-qjYMXrypyb2tJX2__aZc,1533
 thds/mops/pure/_magic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/pure/_magic/api.py,sha256=kSlediIZQYsmeHB8plP6osjvUuSEVW4NWdY9ADia12Y,5094
-thds/mops/pure/_magic/sauce.py,sha256=xLaseOhoGgntmz6nZdj2te85sOaOiWExBLMGdeNmKsI,6870
-thds/mops/pure/_magic/shims.py,sha256=CXN8wlHv039oKRzDtp5YFDlwGXmmaheWLCi2I95gSeM,1212
+thds/mops/pure/_magic/sauce.py,sha256=xmO6Kch-ofVnrVFkxWm84C0-ao9vVCYq0nGGMuYeaok,6333
+thds/mops/pure/_magic/shims.py,sha256=JI49ddv6lEUmNVsEl-XkGlsx2RpOMQoIOSSSfootYE8,1188
 thds/mops/pure/adls/__init__.py,sha256=fw67xxwnizBurScMa-_zWb94lo5gamEVRt27V4bR0jc,54
 thds/mops/pure/adls/_files.py,sha256=9m35Y4elWF0DjgAXVp4oi5CaY6fXWt8n67PilWxWJns,821
 thds/mops/pure/adls/blob_store.py,sha256=ZWr7CKKcI-jz1sWZq4Jwq6LYkhFNxp-EFnNh83EJd84,7374
 thds/mops/pure/adls/output_fqn.py,sha256=qnwdubjVwKShzZ5RruD0_85x86DtPwZNSgwADrdhrTs,748
 thds/mops/pure/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/pure/core/content_addressed.py,sha256=RaCPvtM7bf0NnY5lNR5jPcNn2Moh-bmLtC4zOvdWjCU,1202
-thds/mops/pure/core/deferred_work.py,sha256=zN-iRJj2lUB83SrxOC0JLhfkSWA6qIc1cvSScfkWKOM,3756
+thds/mops/pure/core/deferred_work.py,sha256=3vjfqWFlqLLMcmX4nHVaaiidrG5N5KyAYhw6R0hoMzI,3716
 thds/mops/pure/core/file_blob_store.py,sha256=N4m4LLrBZaqTJFR4D_eYl03a-n6yQBRsv0ID1bOS9TA,4298
 thds/mops/pure/core/metadata.py,sha256=xAL2iz0pXrcKapmYnNrqSZ8nH2GVakA167NSpAfwiCI,8276
 thds/mops/pure/core/output_naming.py,sha256=ntufOVNJiVPiUM-Azl9mFpDFhIxiB-V2je9dv9AUQhg,2283
@@ -61,25 +57,25 @@ thds/mops/pure/core/serialize_paths.py,sha256=bWI-AKNP_Tf29JGO7DKqshOh7b7gu51lfG
 thds/mops/pure/core/source.py,sha256=b0i58gE13e25lIV6ls1yPKH67SQ7aCuZmKDEHNr9Ux4,14682
 thds/mops/pure/core/types.py,sha256=w2g83miGhnjaWr2_4TW2Fc3BdIgoIHFbIr_wX1HC7A0,5452
 thds/mops/pure/core/uris.py,sha256=qO9_f-ro7kax6haNOPTPe81-_aUSRFELeeZH4PMTTU4,2694
-thds/mops/pure/core/use_runner.py,sha256=m1Mu1XDr3xRf_u_VSiHfTG4TH6fnSg0IqwmtbLKG_oc,2103
+thds/mops/pure/core/use_runner.py,sha256=_YeKEjj6_9uc5UIjxcm-YKLUj4joApOdaTJCMaCLC2c,1547
 thds/mops/pure/core/entry/__init__.py,sha256=kiDcsj16CwjRSexOZW-4h4b4tDCYIS_eLS5wgu2yIlk,151
 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/entry/runner_registry.py,sha256=LgEifOYXgjwox1BlBordX1U6g6QB2dAPVU6S1b_iOlk,835
+thds/mops/pure/core/lock/__init__.py,sha256=EP_5T_CF175I01NrVR0eIaWu-k3OM-xsr9pal2i61rU,215
+thds/mops/pure/core/lock/_acquire.py,sha256=wIHvAlh0F4lzfgjga9_eFcfZtzx3G-uCsk06H42OXZA,9093
 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=2VkqKxyp0bZkfM5wZV4Lz7zmZl7t5TOcCGNYfJNFGqs,5250
 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
-thds/mops/pure/core/memo/__init__.py,sha256=k64vX3XazDkP0m8MZgwqt0BV4vXg-ojK1EDhymucnuo,286
+thds/mops/pure/core/lock/write.py,sha256=4z3W9rsRIs5ZI-_g2Q6ZplQdez6DxCGJ-HZikQI3dHo,5614
+thds/mops/pure/core/memo/__init__.py,sha256=OAgSWsup07EKxITr3yjwJ8eXbhU6-P1DVeZaYIgylgc,277
 thds/mops/pure/core/memo/calls.py,sha256=kvm6kn-CbOLxZuo86BvzEJw69p7VlEJ8_mCiWd6uz-g,3631
 thds/mops/pure/core/memo/function_memospace.py,sha256=PlQCs7dZ2Fu3gIjfzJMeOy7R5zPqYQDBp7OuViLqrpc,11644
 thds/mops/pure/core/memo/keyfunc.py,sha256=FAOEDzMcQ-0JvW4j1eaUzixnemo_373V-16kWZl7_i0,2053
 thds/mops/pure/core/memo/overwrite_params.py,sha256=ltuFxhr8gNo2iBoBz2eFPayjSV23gMdBuoLZD42lIAg,2425
-thds/mops/pure/core/memo/results.py,sha256=hEgwlNXRIzihjUMgrlKeHAXDDBmp7y6vQyemzc47hgY,3202
+thds/mops/pure/core/memo/results.py,sha256=kaYJj542Ey5CQgiuCXVGVrKE6ZcdV5H9VD2OCSDi_38,3146
 thds/mops/pure/core/memo/unique_name_for_function.py,sha256=NGuBmK9c-UdgQP27I-WLMRlCMWJmPSdMymRm14mT1K0,2331
 thds/mops/pure/joblib/__init__.py,sha256=-3hSs-GsNzE_eNnwrdZBHAR_eaub5Uyl5GPYqBwEEPo,58
 thds/mops/pure/joblib/backend.py,sha256=F__6lrdc1-VcX4n4Pw7Lz1bBgeefShtRy2DQh6Fp-eI,2671
@@ -87,17 +83,16 @@ thds/mops/pure/joblib/batching.py,sha256=tPOATD28-YW7KcWa3IqKm-fhLaILzM792ApvU-_
 thds/mops/pure/pickling/__init__.py,sha256=WNdG8PdJCk-kYaXkvvPa--hjYGoUlBXG3w2X86yuhGo,156
 thds/mops/pure/pickling/_pickle.py,sha256=YB8xbqDiwdk8ccnVZ2_4kQn98V2JSrFqw2E3J-jEHlA,8081
 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/mprunner.py,sha256=dVbwQA8hzEL7UiwYXmzoGwN3_jbEtGoHDPMkRmo_UtA,8378
+thds/mops/pure/pickling/pickles.py,sha256=nCg7L7CqReNWDF8FAdEmCcuXVC_kLT5zuyW3V8Vvvs4,4704
+thds/mops/pure/pickling/remote.py,sha256=SynT9gVE3D2G2KO9oROa1iopMXxCXprP6_A3xl2IEJ4,5921
 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/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/local.py,sha256=qdAfQVMS5EtZjjrvHfHjiXAQMoVOCxD2rzWdvc2aNbw,12004
+thds/mops/pure/runner/shim_builder.py,sha256=DkOXbPaOWPj2uUsJhjlWmh8ijG9OQc4ciHqa-vHPfXw,709
+thds/mops/pure/runner/simple_shims.py,sha256=oJ8sC5EVD-JFZx8CYE3_QwaQTuFa5F3IYH5PJ9mdMtY,702
 thds/mops/pure/runner/strings.py,sha256=PYAYMxZ2ehgahKIBXJilENNE6OrdNkueNBel8LPsoh8,26
-thds/mops/pure/runner/types.py,sha256=fEpZyLYd1mtM1lRX_1MANpbttnJge0Z1zNqC8tAAxnw,1566
+thds/mops/pure/runner/types.py,sha256=sdeGCig5a-tm4eHrpMCTFsrmh2CBrLfI3kCMdoYqZY0,1127
 thds/mops/pure/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/pure/tools/_pickle_dis.py,sha256=EyLgWP_dRzz1HIabGRTEGZFT_LZV5gmn4asJyFUAt4Y,6312
 thds/mops/pure/tools/history.py,sha256=dB7C2jq-0P3Fnv5Q3nzEkLehXdX0kaZZrGl1U1ns9DU,1048
@@ -106,11 +101,11 @@ thds/mops/pure/tools/sha256_b64_addressed.py,sha256=SECAiw3xSqpsrBBZix0MgJRTQrbH
 thds/mops/pure/tools/stress.py,sha256=N7C8kLpaGbImeEYlT5jsEl1metvsUu8cnfyQ8vFN0H8,2541
 thds/mops/pure/tools/summarize/__init__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
 thds/mops/pure/tools/summarize/cli.py,sha256=7kDtn24ok8oBO3jFjlMmOK3jnZYpMoE_5Y8fmDH8Imc,11524
-thds/mops/pure/tools/summarize/run_summary.py,sha256=w45qiQr7elrHDiK9Hgs85gtU3gwLuXa447ih1Y23BBY,5776
+thds/mops/pure/tools/summarize/run_summary.py,sha256=LUtvbankAYbss2NCF_XbNl05jkNgxYz_SLyERJlp4sk,5773
 thds/mops/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/testing/deferred_imports.py,sha256=f0ezCgQAtzTqW1yAOb0OWgsB9ZrlztLB894LtpWDaVw,3780
-thds_mops-3.9.20250722200009.dist-info/METADATA,sha256=rKMAxner0XGBIimx6ivAihjWTBwwWve3E1SK2bHJJQU,2225
-thds_mops-3.9.20250722200009.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thds_mops-3.9.20250722200009.dist-info/entry_points.txt,sha256=qKvCAaB80syXfxVR3xx6x9J0YJdaQWkIbVSw-NwFgMw,322
-thds_mops-3.9.20250722200009.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_mops-3.9.20250722200009.dist-info/RECORD,,
+thds_mops-3.9.20250722213952.dist-info/METADATA,sha256=qGHDc94PqxO9WS_21Nl0Vgsuh8X3UkvNnCPM1B96L-o,2225
+thds_mops-3.9.20250722213952.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thds_mops-3.9.20250722213952.dist-info/entry_points.txt,sha256=qKvCAaB80syXfxVR3xx6x9J0YJdaQWkIbVSw-NwFgMw,322
+thds_mops-3.9.20250722213952.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds_mops-3.9.20250722213952.dist-info/RECORD,,