thds.mops 3.8.20250502184911__py3-none-any.whl → 3.8.20250602165457__py3-none-any.whl

thds/mops/_compat.py

@@ -4,3 +4,8 @@ try:
     import tomllib  # type: ignore [import-not-found] # noqa: F401
 except ImportError:
     import tomli as tomllib  # noqa: F401
+
+try:
+    import importlib_metadata  # type: ignore [import-not-found] # noqa: F401
+except ImportError:
+    from importlib import metadata as importlib_metadata  # type: ignore[no-redef] # noqa: F401

thds/mops/pure/core/metadata.py

@@ -176,8 +176,11 @@ def parse_result_metadata(metadata_keyvals: ty.Sequence[str]) -> ResultMetadata:
     """
 
     def to_arg(kv: str) -> str:
-        key, value = kv.split("=", 1)
-        return f"--{key.replace('_', '-')}={value}"
+        try:
+            key, value = kv.split("=", 1)
+            return f"--{key.replace('_', '-')}={value}"
+        except ValueError:
+            raise ValueError(f"Unable to parse metadata key-value pair {kv}. Must be key=value.")
 
     metadata = result_metadata_parser().parse_args([to_arg(kv) for kv in metadata_keyvals if kv])
     return ResultMetadata(**vars(metadata))

thds/mops/pure/core/uris.py

@@ -1,4 +1,3 @@
-import importlib.metadata
 import io
 import typing as ty
 from pathlib import Path
@@ -6,6 +5,7 @@ from typing import Callable, Union
 
 from thds.adls import AdlsFqn, AdlsRoot
 from thds.core.stack_context import StackContext
+from thds.mops._compat import importlib_metadata
 
 from ..adls.blob_store import get_adls_blob_store
 from .file_blob_store import get_file_blob_store
@@ -29,7 +29,7 @@ def register_blob_store(get_store: GetBlobStoreForUri) -> None:
 
 
 def load_plugin_blobstores() -> None:
-    for entry_point in importlib.metadata.entry_points().get("thds.mops.pure.blob_stores", []):
+    for entry_point in importlib_metadata.entry_points(group="thds.mops.pure.blob_stores"):
         try:
             register_blob_store(entry_point.load())
         except Exception as e:

thds/mops/pure/pickling/_pickle.py

@@ -80,7 +80,7 @@ def gimme_bytes(pickle_dump: ty.Callable[[object, ty.IO], None], obj: object) ->
         return bio.read()
 
 
-def read_partial_pickle(full_bytes: bytes) -> ty.Tuple[bytes, ty.Any]:
+def read_partial_pickle(full_bytes: bytes) -> ty.Tuple[bytes, bytes]:
     # in order to be forward-compatible with v3 of mops, we're introducing a new
     # wrinkle in the read. Instead of assuming that the data at the URI
     # _begins_ with a pickle, we are looking for the first possible pickle
@@ -89,10 +89,11 @@ def read_partial_pickle(full_bytes: bytes) -> ty.Tuple[bytes, ty.Any]:
     first_pickle_pos = full_bytes.find(b"\x80")
     if first_pickle_pos == -1:
         raise ValueError(f"Unable to find a pickle in bytes of length {len(full_bytes)}")
-    return (
-        full_bytes[:first_pickle_pos],
-        CallableUnpickler(io.BytesIO(full_bytes[first_pickle_pos:])).load(),
-    )
+    return full_bytes[:first_pickle_pos], full_bytes[first_pickle_pos:]
+
+
+def _unpickle_with_callable(pickle_bytes: bytes) -> ty.Any:
+    return CallableUnpickler(io.BytesIO(pickle_bytes)).load()
 
 
 H = ty.TypeVar("H")
@@ -105,8 +106,8 @@ def make_read_header_and_object(
         uri_bytes = get_bytes(uri, type_hint=type_hint)
         if not uri_bytes:
             raise ValueError(f"{uri} exists but is empty - something is very wrong.")
-        header, unpickled = read_partial_pickle(uri_bytes)
-        return (xf_header or (lambda h: h))(header), unpickled  # type: ignore
+        header, first_pickle = read_partial_pickle(uri_bytes)
+        return (xf_header or (lambda h: h))(header), _unpickle_with_callable(first_pickle)  # type: ignore
 
     return read_object
 

thds/mops/pure/tools/_pickle_dis.py

@@ -0,0 +1,141 @@
+import ast
+import io
+import pickletools
+import re
+import typing as ty
+
+from thds.mops.pure.core import metadata, uris
+from thds.mops.pure.core.memo import results
+from thds.mops.pure.pickling._pickle import read_partial_pickle
+from thds.mops.pure.runner import strings
+
+
+def _dis(byts: bytes, indent: int = 4) -> str:
+    """Disassemble the bytes into a string."""
+    ios = io.StringIO()
+    pickletools.dis(byts, out=ios, indentlevel=indent)
+    ios.seek(0)
+    return ios.read()
+
+
+def replace_all_nested_pickles(
+    disassembly_text: str,
+) -> str:
+    """
+    Finds all BINBYTES opcodes whose payload starts with b'\\x80',
+    attempts to disassemble them as pickles, and replaces the BINBYTES
+    section with the nested disassembly if successful.
+    """
+    # Regex to find any BINBYTES line and capture indentation and start offset.
+    binbytes_pattern = re.compile(
+        r"^(?P<indent>[ \t]*)(?P<offset>\d+):\s+(?P<opcode>\S+)\s+BINBYTES\s+", re.MULTILINE
+    )
+
+    # Regex to find the start of the next opcode line after BINBYTES
+    next_opcode_pattern = re.compile(r"^[ \t]*\d+:\s+\S+", re.MULTILINE)
+
+    output_parts = []
+    last_end = 0
+
+    for match in binbytes_pattern.finditer(disassembly_text):
+        indent_str = match.group("indent")
+        binbytes_line_start = match.start()
+        binbytes_line_end = match.end()  # End of the matched BINBYTES prefix
+
+        # Find where the byte literal starts (b" or b') after the opcode
+        bytes_literal_start_index = -1
+        b_quote_match = re.search(r'b["\']', disassembly_text[binbytes_line_end:])
+        if b_quote_match:
+            bytes_literal_start_index = binbytes_line_end + b_quote_match.start()
+        else:
+            # Malformed BINBYTES line? Skip this match.
+            # Append text up to the start of this BINBYTES line and continue searching
+            output_parts.append(disassembly_text[last_end:binbytes_line_start])
+            last_end = binbytes_line_start  # Start next search from here
+            continue
+
+        # Find the start of the *next* opcode line to delimit the byte literal
+        next_opcode_match = next_opcode_pattern.search(disassembly_text, pos=binbytes_line_end)
+        end_of_binbytes_section = (
+            next_opcode_match.start() if next_opcode_match else len(disassembly_text)
+        )
+
+        # Extract the full string representation of the bytes literal
+        potential_bytes_str = disassembly_text[
+            bytes_literal_start_index:end_of_binbytes_section
+        ].rstrip()
+
+        nested_disassembly = None
+        try:
+            # Evaluate the string literal to get bytes
+            actual_bytes = ast.literal_eval(potential_bytes_str)
+            if not isinstance(actual_bytes, bytes):
+                raise ValueError("Literal did not evaluate to bytes")
+
+            # --- Key Check: Does it start with a pickle protocol marker? ---
+            if actual_bytes.startswith(b"\x80"):
+                # Attempt to disassemble these bytes
+                indent_level = len(indent_str)
+                # Use a deeper indent for the nested part
+                nested_disassembly = _dis(actual_bytes, indent=indent_level + 4)
+
+        except (SyntaxError, ValueError, TypeError):
+            # Failed to parse the bytes literal string itself. Keep original.
+            # print(f"Debug: Failed to eval bytes literal near offset {match.group('offset')}: {e_eval}")
+            nested_disassembly = None  # Ensure it stays None
+        except Exception:  # Catch errors from _dis (e.g., not valid pickle)
+            # Failed to disassemble. Keep original.
+            # print(f"Debug: Failed to disassemble potential pickle near offset {match.group('offset')}: {e_dis}")
+            nested_disassembly = None  # Ensure it stays None
+
+        # --- Construct the output ---
+        # Append text before this BINBYTES line
+        output_parts.append(disassembly_text[last_end:binbytes_line_start])
+
+        if nested_disassembly:
+            # Successfully disassembled, replace the BINBYTES section
+            # Append the original BINBYTES line itself (for context)
+            output_parts.append(
+                disassembly_text[binbytes_line_start:binbytes_line_end]
+            )  # Just the "XXX: B BINBYTES" part
+            output_parts.append(f"--- NESTED PICKLE ({len(actual_bytes)} bytes) START ---\n")
+            output_parts.append(nested_disassembly)
+            output_parts.append(f"{indent_str}--- NESTED PICKLE END ---\n")
+            # Update last_end to skip the original byte literal representation
+            last_end = end_of_binbytes_section
+        else:
+            # Did not replace, append the original BINBYTES section unchanged
+            output_parts.append(disassembly_text[binbytes_line_start:end_of_binbytes_section])
+            # Update last_end
+            last_end = end_of_binbytes_section
+
+    # Append any remaining text after the last match
+    output_parts.append(disassembly_text[last_end:])
+
+    return "".join(output_parts)
+
+
+def get_meta_and_pickle(uri: str) -> tuple[ty.Optional[metadata.ResultMetadata], str]:
+    """To be used when the issue is internal to the pickle itself."""
+
+    def _replace_all_dis_numbers(
+        disassembly_text: str,
+    ) -> str:
+        # Replace all line numbers with a placeholder
+        lines = disassembly_text.splitlines()
+        return "\n".join([re.sub(r"^(\s*)\d+:", r"\1 ", line) for line in lines])
+
+    if uri.endswith("/" + strings.INVOCATION):
+        _, invoc_raw = read_partial_pickle(uris.get_bytes(uri, type_hint=strings.INVOCATION))
+        # the raw invocation itself contains a nested pickle. we want to show the outer opcodes of the
+        # raw invocation, and then we _also_ want to pull out the inner args_kwargs_pickle and show
+        # the opcodes of that one, preferably without repeating ourselves too much.
+        invoc_dis = _dis(invoc_raw)
+        return None, _replace_all_dis_numbers(replace_all_nested_pickles(invoc_dis))
+
+    # TODO maybe handle exception type hinting here?
+    meta_bytes, first_pickle = read_partial_pickle(uris.get_bytes(uri, type_hint=results.RESULT))
+    return (
+        metadata.parse_result_metadata(meta_bytes.decode("utf-8").split("\n")),
+        _replace_all_dis_numbers(_dis(first_pickle)),
+    )

thds/mops/pure/tools/inspect.py

@@ -8,9 +8,11 @@ but if you're reading this in the distant future - those are its limitations.
 
 import argparse
 import functools
+import io
 import os
 import re
 import subprocess
+import sys
 import typing as ty
 from dataclasses import dataclass
 from pathlib import Path
@@ -29,6 +31,8 @@ from thds.mops.pure.pickling._pickle import (
 from thds.mops.pure.pickling.pickles import Invocation
 from thds.mops.pure.runner import strings
 
+from . import _pickle_dis
+
 logger = log.getLogger(__name__)
 
 
@@ -59,6 +63,7 @@ def _unpickle_object_for_debugging(uri: str) -> ty.Any:
             invoc = ty.cast(Invocation, invoc_raw)
             args, kwargs = unfreeze_args_kwargs(invoc.args_kwargs_pickle, PartialViewingUnpickler)
             return Thunk(getattr(invoc, "f", None) or invoc.func, *args, **kwargs)
+
         header, obj = read_metadata_and_object("output", uri)
         return obj, header
     except ImportError as ie:
@@ -98,7 +103,7 @@ def _control_uri(uri: str) -> str:
 
 
 @scope.bound
-def get_control_file(uri: str) -> ty.Any:
+def get_control_file(uri: str, unpickle: bool = True) -> ty.Any:
     """Returns _NOTHING if 'normal' errors occur."""
     try:
         uri = _resolved_uri(uri)
@@ -109,18 +114,27 @@ def get_control_file(uri: str) -> ty.Any:
     if not _control_uri(uri):
         fs = uris.lookup_blob_store(uri)
         logger.debug(f"Attempting to fetch all control files for {uri}")
-        return IRE(**{cf: get_control_file(fs.join(uri, cf)) for cf in _KNOWN_CONTROL_FILES})
+        return IRE(
+            **{cf: get_control_file(fs.join(uri, cf), unpickle=unpickle) for cf in _KNOWN_CONTROL_FILES}
+        )
 
     has_storage_root = bool(uris.ACTIVE_STORAGE_ROOT())
     try:
         scope.enter(uris.ACTIVE_STORAGE_ROOT.set(uris.get_root(uri)))
-        return _unpickle_object_for_debugging(uri)
+        if unpickle:
+            return _unpickle_object_for_debugging(uri)
+        else:
+            return _pickle_dis.get_meta_and_pickle(uri)
+    except ImportError:
+        return None
     except Exception as e:
         if uris.lookup_blob_store(uri).is_blob_not_found(e):
             if has_storage_root or uri not in str(e):
                 logger.warning(str(e))
             return None
-        logger.exception("Unexpected error while unpickling the object.")
+        logger.exception(
+            f"Unexpected error {e} while {'unpickling' if unpickle else 'processing'} the object at {uri}"
+        )
         raise
 
 
@@ -136,22 +150,31 @@ def _embed(o: object) -> None:
 
 
 def _pprint(obj: object, file: ty.Any = None, uri: str = "") -> None:
+    final_out_stream = file or sys.stdout
+
     if uri:
-        print(uri, file=file)
+        print(uri, file=final_out_stream)
+
+    # Always capture the pretty-printed output to an in-memory buffer first
+    output_buffer = io.StringIO()
 
     try:
-        from rich import console, pretty  # type: ignore[import]
-
-        if file:
-            console.Console(file=file, color_system=None).print(
-                pretty.Pretty(
-                    obj,  # highlighter=lambda x: x if file else None
-                )
-            )
-        else:
-            pretty.pprint(obj)
+        # Attempt to use rich for pretty-printing into the buffer
+        from rich import console, pretty  # type: ignore[import-not-found]
+
+        console.Console(file=output_buffer, color_system=None).print(pretty.Pretty(obj), crop=False)
     except ModuleNotFoundError:
-        pprint(obj, indent=4, width=60, sort_dicts=False, stream=file)
+        pprint(obj, indent=4, width=60, sort_dicts=False, stream=output_buffer)
+
+    formatted_string = output_buffer.getvalue()
+    # Unescape the literal '\n' sequences into actual newlines
+    processed_string = re.sub(r"(?<!\\)\\n", "\n", formatted_string)
+
+    # Use print with end='' for stdout to avoid double newlines
+    if final_out_stream is sys.stdout:
+        print(processed_string, end="")
+    else:
+        final_out_stream.write(processed_string)
 
 
 def inspect(uri: str, embed: bool = False) -> ty.Any:
@@ -255,6 +278,25 @@ def _write_ire_to_path(ire: IRE, path: Path, uri: str) -> None:
         _pprint(ire, file=wf, uri=uri)
 
 
+@scope.bound
+def pickle_diff_two_uris(uri1: str, uri2: str) -> None:
+    """Diff two pickled objects, using the diff tool specified in DIFF_TOOL."""
+    _check_diff_tool()
+    uri1 = _resolved_uri(uri1)
+    uri2 = _resolved_uri(uri2)
+
+    path1 = scope.enter(tmp.temppath_same_fs())
+    path2 = scope.enter(tmp.temppath_same_fs())
+
+    ire1 = get_control_file(uri1, unpickle=False)
+    ire2 = get_control_file(uri2, unpickle=False)
+
+    _write_ire_to_path(ire1, path1, uri1)
+    _write_ire_to_path(ire2, path2, uri2)
+
+    _run_diff_tool(path1, path2)
+
+
 def _diff_memospace(uri: str, new_control: IRE) -> None:
     """Diff all siblings in the memospace against the new invocation.
 
@@ -347,6 +389,11 @@ def main() -> None:
             " It is highly recommended that you `brew install difftastic` to get more precise diffs."
         ),
     )
+    parser.add_argument(
+        "--diff-pickle-ops",
+        "-p",
+        help="""Diff against the provided memo URI, but emit pickle opcodes rather than unpickling.""",
+    )
     parser.add_argument(
         "--loop",
         action="store_true",
@@ -355,16 +402,22 @@ def main() -> None:
     parser.add_argument("--embed", action="store_true", help="Embed an IPython shell after inspection.")
     args = parser.parse_args()
     args.uri = args.uri.rstrip("/")
-    if args.diff_memospace:
+    if args.diff_memospace or args.diff_pickle_ops:
         _check_diff_tool()
 
-    _inspect_uri(args.uri, args.diff_memospace, args.embed)
+    if args.diff_pickle_ops:
+        pickle_diff_two_uris(args.uri, args.diff_pickle_ops)
+    else:
+        _inspect_uri(args.uri, args.diff_memospace, args.embed)
 
     if args.loop:
         prompt = "\nEnter another URI to inspect, or empty string to exit: "
         uri = input(prompt)
         while uri:
-            _inspect_uri(uri, args.diff_memospace, args.embed)
+            if args.diff_pickle_ops:
+                pickle_diff_two_uris(args.uri, uri)
+            else:
+                _inspect_uri(uri, args.diff_memospace, args.embed)
             uri = input(prompt)
 
 

{thds_mops-3.8.20250502184911.dist-info → thds_mops-3.8.20250602165457.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thds.mops
-Version: 3.8.20250502184911
+Version: 3.8.20250602165457
 Summary: ML Ops tools for Trilliant Health
 Author-email: Trilliant Health <info@trillianthealth.com>
 Project-URL: Repository, https://github.com/TrilliantHealth/ds-monorepo
@@ -11,6 +11,7 @@ Requires-Dist: azure-core
 Requires-Dist: azure-identity
 Requires-Dist: azure-storage-file-datalake
 Requires-Dist: cachetools
+Requires-Dist: importlib_metadata>=3.6; python_version < "3.10"
 Requires-Dist: tblib~=2.0
 Requires-Dist: thds-adls
 Requires-Dist: thds-core

{thds_mops-3.8.20250502184911.dist-info → thds_mops-3.8.20250602165457.dist-info}/RECORD

@@ -1,6 +1,6 @@
 thds/mops/__about__.py,sha256=IW_3wy8wEdrVducoBdiVgD7oYOY4J8yO1ezBaPtrc6U,215
 thds/mops/__init__.py,sha256=dbujDxVVfHpWP7OyfjEdNVHLtKx99rsNQPYfjTKn5Lg,127
-thds/mops/_compat.py,sha256=nArultEBSfWeT8eJOETN-H3vd4miEhZBXwjc6cCCtTc,157
+thds/mops/_compat.py,sha256=fO1YYEu6LF1re-VXl4P_8RXXLeKt4BgI9NTlHTgNpLk,357
 thds/mops/config.py,sha256=T62YskXvzAfxNgpq2jMatHgoIHfRV_z4cvJ8Rl_TZ6E,2015
 thds/mops/parallel.py,sha256=FIWm53NJF1X910sTUGhqYj_XJWaSzgEDdsZq9siDvhk,926
 thds/mops/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,7 +47,7 @@ thds/mops/pure/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 thds/mops/pure/core/content_addressed.py,sha256=OQvEzRl9RWUCPCISUEv6kIUEroPGKlsAuBqTrV2tkx4,1101
 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=1BFtRVESTpgDQs2mMvBIWJ4W5oPN19qxcgrILgE3_Tg,8130
+thds/mops/pure/core/metadata.py,sha256=xAL2iz0pXrcKapmYnNrqSZ8nH2GVakA167NSpAfwiCI,8276
 thds/mops/pure/core/output_naming.py,sha256=ntufOVNJiVPiUM-Azl9mFpDFhIxiB-V2je9dv9AUQhg,2283
 thds/mops/pure/core/partial.py,sha256=aeNQFNHj9epU6lvk6NNTV6hXkNqNHN_czBydt7nkHmg,463
 thds/mops/pure/core/pipeline_id.py,sha256=rQP6uhwP-2rqpOxQiEOfQbRdQL0q8zSGJrb7YywlO-A,2102
@@ -57,7 +57,7 @@ thds/mops/pure/core/serialize_big_objs.py,sha256=YcOS1ccs82ZWO7nTbeumErMzYVe4hgX
 thds/mops/pure/core/serialize_paths.py,sha256=bWI-AKNP_Tf29JGO7DKqshOh7b7gu51lfGryDXo3aMI,5787
 thds/mops/pure/core/source.py,sha256=f7qtgKE5q75_uq27mgtIDGMWSvakzzpB3kAsTKo4TWw,13549
 thds/mops/pure/core/types.py,sha256=w2g83miGhnjaWr2_4TW2Fc3BdIgoIHFbIr_wX1HC7A0,5452
-thds/mops/pure/core/uris.py,sha256=oRiBM92xFwhbFSf4OIjJYQMmDGTRglndb_n4lpilsbs,2675
+thds/mops/pure/core/uris.py,sha256=qO9_f-ro7kax6haNOPTPe81-_aUSRFELeeZH4PMTTU4,2694
 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=H5NHl2WgKN-3czlDjJeJLhyXOZ38c2ixGTbh6T3SfgQ,1806
@@ -82,7 +82,7 @@ thds/mops/pure/joblib/__init__.py,sha256=-3hSs-GsNzE_eNnwrdZBHAR_eaub5Uyl5GPYqBw
 thds/mops/pure/joblib/backend.py,sha256=F__6lrdc1-VcX4n4Pw7Lz1bBgeefShtRy2DQh6Fp-eI,2671
 thds/mops/pure/joblib/batching.py,sha256=tPOATD28-YW7KcWa3IqKm-fhLaILzM792ApvU-_zfnM,2298
 thds/mops/pure/pickling/__init__.py,sha256=WNdG8PdJCk-kYaXkvvPa--hjYGoUlBXG3w2X86yuhGo,156
-thds/mops/pure/pickling/_pickle.py,sha256=oBt2LX3_Bm33lFmQiOdQq0zIdPjDmPY8je2ICWgUQbo,7514
+thds/mops/pure/pickling/_pickle.py,sha256=vn8f6uEsaAdLyxGNYb4ED6D1a6BXsZQxnV3c0Ya6WUk,7605
 thds/mops/pure/pickling/memoize_only.py,sha256=oI5CMy6IEJc46Gb_BGWNUuAe3fysS7HxRSTajN0WssI,837
 thds/mops/pure/pickling/mprunner.py,sha256=dVbwQA8hzEL7UiwYXmzoGwN3_jbEtGoHDPMkRmo_UtA,8378
 thds/mops/pure/pickling/pickles.py,sha256=nCg7L7CqReNWDF8FAdEmCcuXVC_kLT5zuyW3V8Vvvs4,4704
@@ -95,8 +95,9 @@ thds/mops/pure/runner/simple_shims.py,sha256=oJ8sC5EVD-JFZx8CYE3_QwaQTuFa5F3IYH5
 thds/mops/pure/runner/strings.py,sha256=PYAYMxZ2ehgahKIBXJilENNE6OrdNkueNBel8LPsoh8,26
 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
-thds/mops/pure/tools/inspect.py,sha256=nvEQqZwWvBAc3wvfYVUWPkT4tH_v0O2jUo8eAJPC9Fc,12190
+thds/mops/pure/tools/inspect.py,sha256=PYXmR9-ATB3UsJUDG5Up8B6mdfenOGx2nktjw3sxMX8,13957
 thds/mops/pure/tools/sha256_b64_addressed.py,sha256=SECAiw3xSqpsrBBZix0MgJRTQrbHiUk2oFHYa7ln3q4,1137
 thds/mops/pure/tools/stress.py,sha256=f7pL5n9BmVYSZrmDJxKnUC70AIfeHhU5B9E9UDs5GJ8,2544
 thds/mops/pure/tools/summarize/__init__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
@@ -104,8 +105,8 @@ thds/mops/pure/tools/summarize/cli.py,sha256=gaechsJhRZsOxGJGG1dQsW5dMBlgSv2sUmE
 thds/mops/pure/tools/summarize/run_summary.py,sha256=ujJC24J0XsF5W5P-eHiIq-4gmedmFXk2g1uljuvqOvc,5373
 thds/mops/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/mops/testing/deferred_imports.py,sha256=f0ezCgQAtzTqW1yAOb0OWgsB9ZrlztLB894LtpWDaVw,3780
-thds_mops-3.8.20250502184911.dist-info/METADATA,sha256=bYjWQQeZfb_gt-VtXg2ngfEMijrCeMKlR35qFc4GW2c,2158
-thds_mops-3.8.20250502184911.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-thds_mops-3.8.20250502184911.dist-info/entry_points.txt,sha256=GShNqjcjbq0TAJuwpyeCI5XCltiwdZxnNHkBpmYbNkU,329
-thds_mops-3.8.20250502184911.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_mops-3.8.20250502184911.dist-info/RECORD,,
+thds_mops-3.8.20250602165457.dist-info/METADATA,sha256=ywsEaxLyt2BegJ_UbgTVQUVXsWtrM5PnOFFpX0IOkhk,2222
+thds_mops-3.8.20250602165457.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thds_mops-3.8.20250602165457.dist-info/entry_points.txt,sha256=GShNqjcjbq0TAJuwpyeCI5XCltiwdZxnNHkBpmYbNkU,329
+thds_mops-3.8.20250602165457.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds_mops-3.8.20250602165457.dist-info/RECORD,,

{thds_mops-3.8.20250502184911.dist-info → thds_mops-3.8.20250602165457.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any