thds.core 1.40.20250701001211__py3-none-any.whl → 1.40.20250701190355__py3-none-any.whl

thds/core/__init__.py

@@ -8,6 +8,7 @@ from . import (  # noqa: F401
     config,
     decos,
     dict_utils,
+    dump_stacks,
     env,
     exit_after,
     files,

thds/core/cpus.py

@@ -39,7 +39,20 @@ def _try_read_value(config_path: Path, parse: ty.Callable[[str], T]) -> ty.Optio
 
 def _parse_cpu_quota_and_period_v2(s: str) -> ty.Tuple[int, int]:
     """Parse both CPU quota and period from kernel cgroup v2 config file."""
-    quota, period = map(int, s.split())
+
+    parts = s.split()
+    quota_str, period_str = parts[0], parts[1]
+
+    if quota_str == "max":
+        # https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html
+        #
+        # "In the above four control files, the special token “max” should be used
+        # to represent upward infinity for both reading and writing."
+        quota = -1  # Use -1 to indicate unlimited, matching v1 behavior
+    else:
+        quota = int(quota_str)
+
+    period = int(period_str)
     return quota, period
 
 

thds/core/dump_stacks.py

@@ -0,0 +1,29 @@
+import signal
+import sys
+import threading
+import traceback
+
+
+def dump_all_stacks(signum, frame):
+    print(f"\n=== Stack dump triggered by signal {signum} ===", flush=True)
+    for thread in threading.enumerate():
+        print(f"\nThread: {thread.name} (ID: {thread.ident})", flush=True)
+        print("-" * 50, flush=True)
+        if thread.ident in sys._current_frames():
+            traceback.print_stack(sys._current_frames()[thread.ident], file=sys.stdout)
+        else:
+            print("No frame available for this thread", flush=True)
+    print("=== End stack dump ===\n", flush=True)
+
+
+def setup_signal_handler(signal_num: int = signal.SIGUSR1):
+    """
+    Set up a signal handler to dump all thread stacks when the specified signal is received.
+    Default is SIGUSR1, but can be changed to any other signal as needed.
+    """
+    signal.signal(signal_num, dump_all_stacks)
+
+    print(
+        f"Signal handler set up for signal {signal_num}."
+        " Send this signal to the process to dump all thread stacks."
+    )

thds/core/hash_cache.py

@@ -11,18 +11,16 @@ functions themselves.
 """
 
 import hashlib
-import os
 import sys
 from pathlib import Path
-from typing import Any
 
 from . import config, files
-from .hashing import Hash, hash_using
+from .hashing import Hash, Hasher, get_hasher, hash_using
 from .home import HOMEDIR
 from .log import getLogger
 from .types import StrOrPath
 
-CACHE_HASH_DIR = config.item("directory", HOMEDIR() / ".hash-cache", parse=Path)
+CACHE_HASH_DIR = config.item("directory", HOMEDIR() / ".thds/core/hash-cache", parse=Path)
 _1GB = 1 * 2**30  # log if hashing a file larger than this, since it will be slow.
 
 
@@ -53,7 +51,7 @@ def _is_no_older_than(file: Path, other: Path) -> bool:
     return file.stat().st_mtime >= other.stat().st_mtime
 
 
-def hash_file(filepath: StrOrPath, hasher: Any) -> bytes:
+def hash_file(filepath: StrOrPath, hasher: Hasher) -> bytes:
     """Hashes a file with the given hashlib hasher. If we've already previously computed
     the given hash for the file and the file hasn't changed (according to filesystem
     mtime) since we stored that hash, we'll just return the cached hash.
@@ -74,14 +72,22 @@ def hash_file(filepath: StrOrPath, hasher: Any) -> bytes:
         # I want to know how often we're finding 'outdated' hashes; those should be rare.
         log_at_lvl(f"Hashing {psize/_1GB:.2f} GB file at {resolved_path}{hash_cached}")
 
-    hash_bytes = hash_using(resolved_path, hasher).digest()
+    if hasattr(hasher, "update_mmap"):
+        # a special case for the blake3 module, which has deadlocked in the past
+        logger.warning("DEBUG starting update_mmap for blake3")
+        hasher.update_mmap(filepath)
+        hash_bytes = hasher.digest()
+        logger.info("DEBUG finished update_mmap")
+    else:
+        hash_bytes = hash_using(resolved_path, hasher).digest()
+
     cached_hash_path.parent.mkdir(parents=True, exist_ok=True)
     with files.atomic_binary_writer(cached_hash_path) as f:
         f.write(hash_bytes)
     return hash_bytes
 
 
-def filehash(algo: str, pathlike: os.PathLike) -> Hash:
+def filehash(algo: str, pathlike: StrOrPath) -> Hash:
     """Wraps a cached hash of a file in a core.hashing.Hash object, which carries the name
     of the hash algorithm used."""
-    return Hash(sys.intern(algo), hash_file(pathlike, hashlib.new(algo)))
+    return Hash(sys.intern(algo), hash_file(pathlike, get_hasher(algo)))

thds/core/hashing.py

@@ -2,39 +2,53 @@
 https://stackoverflow.com/questions/3431825/generating-an-md5-checksum-of-a-file
 I have written this code too many times to write it again. Why isn't this in the stdlib?
 """
+
 import base64
 import contextlib
+import hashlib
 import io
 import os
-import threading
 import typing as ty
 from pathlib import Path
 
-# Python threads don't allow for significant CPU parallelism, so
-# allowing for more than a few of these per process is a recipe for
-# getting nothing done.
-_SEMAPHORE = threading.BoundedSemaphore(int(os.getenv("THDS_CORE_HASHING_PARALLELISM", 4)))
-_CHUNK_SIZE = int(os.getenv("THDS_CORE_HASHING_CHUNK_SIZE", 65536))
+from .types import StrOrPath
+
+_CHUNK_SIZE = int(os.getenv("THDS_CORE_HASHING_CHUNK_SIZE", 2**18))
 # https://stackoverflow.com/questions/17731660/hashlib-optimal-size-of-chunks-to-be-used-in-md5-update
-# this may not apply to us as the architecture is 32 bit, but it's at
-# least a halfway decent guess and benchmarking this ourselves would
-# be a massive waste of time.
+# i've done some additional benchmarking, and slightly larger chunks (256 KB) are faster
+# when the files are larger, and those are the ones we care about most since they take the longest.
+
+
+class Hasher(ty.Protocol):
+    """This may be incomplete as far as hashlib is concerned, but it covers everything we use."""
+
+    @property
+    def name(self) -> str:
+        """The name of the hashing algorithm, e.g. 'sha256'."""
+        ...
 
-T = ty.TypeVar("T")
+    def update(self, __byteslike: ty.Union[bytes, bytearray, memoryview]) -> None:
+        """Update the hash object with the bytes-like object."""
+        ...
+
+    def digest(self) -> bytes:
+        ...
+
+
+H = ty.TypeVar("H", bound=Hasher)
 SomehowReadable = ty.Union[ty.AnyStr, ty.IO[ty.AnyStr], Path]
 
 
-def hash_readable_chunks(bytes_readable: ty.IO[bytes], hasher: T) -> T:
+def hash_readable_chunks(bytes_readable: ty.IO[bytes], hasher: H) -> H:
     """Return thing you can call .digest or .hexdigest on.
 
     E.g.:
 
     hash_readable_chunks(open(Path('foo/bar'), 'rb'), hashlib.sha256()).hexdigest()
     """
-    with _SEMAPHORE:
-        for chunk in iter(lambda: bytes_readable.read(_CHUNK_SIZE), b""):
-            hasher.update(chunk)  # type: ignore
-        return hasher
+    for chunk in iter(lambda: bytes_readable.read(_CHUNK_SIZE), b""):
+        hasher.update(chunk)  # type: ignore
+    return hasher
 
 
 @contextlib.contextmanager
@@ -53,7 +67,7 @@ def attempt_readable(thing: SomehowReadable) -> ty.Iterator[ty.IO[bytes]]:
         yield readable
 
 
-def hash_using(data: SomehowReadable, hasher: T) -> T:
+def hash_using(data: SomehowReadable, hasher: H) -> H:
     """This is quite dynamic - but if your data object is not readable
     bytes and is not openable as bytes, you'll get a
     FileNotFoundError, or possibly a TypeError or other gremlin.
@@ -66,7 +80,7 @@ def hash_using(data: SomehowReadable, hasher: T) -> T:
         return hash_readable_chunks(readable, hasher)
 
 
-def hash_anything(data: SomehowReadable, hasher: T) -> ty.Optional[T]:
+def hash_anything(data: SomehowReadable, hasher: H) -> ty.Optional[H]:
     try:
         return hash_using(data, hasher)
     except (FileNotFoundError, TypeError):
@@ -104,3 +118,22 @@ class Hash(ty.NamedTuple):
 
     def __repr__(self) -> str:
         return f"Hash(algo='{self.algo}', bytes={_repr_bytes(self.bytes)})"
+
+
+_NAMED_HASH_CONSTRUCTORS: ty.Dict[str, ty.Callable[[str], Hasher]] = {}
+
+
+def add_named_hash(algo: str, constructor: ty.Callable[[str], Hasher]) -> None:
+    _NAMED_HASH_CONSTRUCTORS[algo] = constructor
+
+
+def get_hasher(algo: str) -> Hasher:
+    if algo in _NAMED_HASH_CONSTRUCTORS:
+        return _NAMED_HASH_CONSTRUCTORS[algo](algo)
+
+    return hashlib.new(algo)
+
+
+def file(algo: str, pathlike: StrOrPath) -> bytes:
+    """I'm so lazy"""
+    return hash_using(pathlike, get_hasher(algo)).digest()

thds/core/meta.py

@@ -198,7 +198,7 @@ class NoBasePackageFromMain(ValueError):
 
 
 @lru_cache(None)
-def get_base_package(pkg: Package) -> str:
+def get_base_package(pkg: Package, *, orig: Package = "") -> str:
     try:
         str_pkg = str(pkg)
         if str_pkg == "__main__":
@@ -210,10 +210,12 @@ def get_base_package(pkg: Package) -> str:
         except PackageNotFoundError:
             pkg_ = pkg.split(".")
             if len(pkg_) <= 1:
-                LOGGER.warning("Could not find the base package for `%s`. Package not found.", pkg)
+                LOGGER.warning(
+                    "Could not find the base package for `%s`. Package %s not found.", orig, pkg
+                )
                 return ""
-            else:
-                return get_base_package(".".join(pkg_[:-1]))
+
+            return get_base_package(".".join(pkg_[:-1]), orig=orig or pkg)
 
     return str(pkg)
 

thds/core/source/__init__.py

@@ -4,6 +4,7 @@ yet will not be downloaded (if non-local) until it is actually opened or unwrapp
 """
 
 from . import serde, tree  # noqa: F401
+from ._construct import set_file_autohash  # noqa: F401
 from ._construct import from_file, from_uri, path_from_uri, register_from_uri_handler  # noqa: F401
 from ._construct_tree import tree_from_directory  # noqa: F401
 from ._download import Downloader, register_download_handler  # noqa: F401

thds/core/source/_construct.py

@@ -1,15 +1,37 @@
 import os
+import sys
 import typing as ty
 from functools import partial
 from pathlib import Path
 
+from .. import log
 from ..files import is_file_uri, path_from_uri, to_uri
-from ..hashing import Hash
-from . import _download
+from ..hash_cache import filehash
+from ..hashing import Hash, Hasher, add_named_hash
 from .src import Source
 
 # Creation from local Files or from remote URIs
 
+_AUTOHASH = "sha256"
+
+
+def set_file_autohash(
+    algo: str, hash_constructor: ty.Optional[ty.Callable[[str], Hasher]] = None
+) -> None:
+    """If you call this and provide a non-builtin hash algorithm, you must also provide a constructor for it."""
+    if hash_constructor:
+        hash_constructor(algo)  # this will raise if algo is not supported.
+        add_named_hash(algo, hash_constructor)
+    global _AUTOHASH
+    _AUTOHASH = sys.intern(algo)
+
+
+def hash_file(path: Path, algo: str = "") -> Hash:
+    hash_algo = sys.intern(algo or _AUTOHASH)
+    with log.logger_context(hash_for=f"source-{hash_algo}"):
+        computed_hash = filehash(hash_algo, path)
+        return computed_hash
+
 
 def from_file(
     filename: ty.Union[str, os.PathLike], hash: ty.Optional[Hash] = None, uri: str = ""
@@ -24,10 +46,11 @@ def from_file(
     if not path.exists():
         raise FileNotFoundError(path)
 
+    file_hash = hash or hash_file(path)  # use automatic hash algo if not specified!
     if uri:
-        src = from_uri(uri, _download._check_hash(hash, path))
+        src = from_uri(uri, file_hash)
     else:
-        src = Source(to_uri(path), _download._check_hash(hash, path))
+        src = Source(to_uri(path), file_hash)
     src._set_cached_path(path)  # internally, it's okay to hack around immutability.
     return src
 

thds/core/source/_download.py

@@ -3,16 +3,12 @@
 yet will not be downloaded (if non-local) until it is actually opened or unwrapped.
 """
 
-import sys
 import typing as ty
 from pathlib import Path
 
-from .. import log
 from ..files import is_file_uri, path_from_uri
-from ..hash_cache import filehash
 from ..hashing import Hash
-
-SHA256 = "sha256"  # this hopefully interns the string which makes sure that all our pickles reuse the reference
+from ._construct import hash_file
 
 
 class Downloader(ty.Protocol):
@@ -76,9 +72,7 @@ class SourceHashMismatchError(ValueError):
 
 
 def _check_hash(expected_hash: ty.Optional[Hash], path: Path) -> Hash:
-    hash_algo = sys.intern(expected_hash.algo if expected_hash else SHA256)
-    with log.logger_context(hash_for=f"source-{hash_algo}"):
-        computed_hash = filehash(hash_algo, path)
+    computed_hash = hash_file(path)
     if expected_hash and expected_hash != computed_hash:
         raise SourceHashMismatchError(
             f"{expected_hash.algo} mismatch for {path};"

thds/core/source/serde.py

@@ -1,13 +1,11 @@
 # this should later get promoted somewhere, probably
 import json
 import typing as ty
-from functools import partial
 from pathlib import Path
 
 from thds.core import files, hashing, log, types
 
 from . import _construct
-from ._download import SHA256
 from .src import Source
 
 _SHA256_B64 = "sha256b64"
@@ -17,20 +15,16 @@ MD5 = "md5"
 logger = log.getLogger(__name__)
 
 
-def _from_sha256b64(d: dict) -> ty.Optional[hashing.Hash]:
-    if "sha256b64" in d:
-        return hashing.Hash(algo=SHA256, bytes=hashing.db64(d[_SHA256_B64]))
-    return None
-
-
-def _from_md5b64(d: dict) -> ty.Optional[hashing.Hash]:
-    if "md5b64" in d:
-        return hashing.Hash(algo=MD5, bytes=hashing.db64(d[_MD5_B64]))
+def _from_b64(d: dict) -> ty.Optional[hashing.Hash]:
+    for key in d.keys():
+        if key.endswith("b64"):
+            algo = key[:-3]
+            return hashing.Hash(algo=algo, bytes=hashing.db64(d[key]))
     return None
 
 
 HashParser = ty.Callable[[dict], ty.Optional[hashing.Hash]]
-_BASE_PARSERS = (_from_sha256b64, _from_md5b64)
+_BASE_PARSERS = (_from_b64,)
 
 
 def base_parsers() -> ty.Tuple[HashParser, ...]:
@@ -45,19 +39,12 @@ def from_json(json_source: str, hash_parsers: ty.Collection[HashParser] = base_p
     )
 
 
-def _generic_hash_serializer(
-    algo: str, stringify_hash: ty.Callable[[bytes], str], keyname: str, hash: hashing.Hash
-) -> ty.Optional[dict]:
-    if hash.algo == algo:
-        return {keyname: stringify_hash(hash.bytes)}
-    return None
-
+def _very_generic_b64_hash_serializer(hash: hashing.Hash) -> dict:
+    return {hash.algo + "b64": hashing.b64(hash.bytes)}
 
-_to_sha256b64 = partial(_generic_hash_serializer, SHA256, hashing.b64, _SHA256_B64)
-_to_md5b64 = partial(_generic_hash_serializer, MD5, hashing.b64, _MD5_B64)
 
 HashSerializer = ty.Callable[[hashing.Hash], ty.Optional[dict]]
-_BASE_HASH_SERIALIZERS: ty.Tuple[HashSerializer, ...] = (_to_md5b64, _to_sha256b64)  # type: ignore
+_BASE_HASH_SERIALIZERS: ty.Tuple[HashSerializer, ...] = (_very_generic_b64_hash_serializer,)
 
 
 def base_hash_serializers() -> ty.Tuple[HashSerializer, ...]:

thds/core/source/src.py

@@ -4,7 +4,6 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from .. import hashing, types
-from . import _download
 
 
 @dataclass(frozen=True)
@@ -73,6 +72,8 @@ class Source(os.PathLike):
         failure will raise SourceHashMismatchError.
         """
         if self.cached_path is None or not self.cached_path.exists():
+            from . import _download  # ugly circular import
+
             lpath = _download._get_download_handler(self.uri)(self.hash)
             # path() used to be responsible for checking the hash, but since we pass it to the downloader,
             # it really makes more sense to allow the downloader to decide how to verify its own download,

{thds_core-1.40.20250701001211.dist-info → thds_core-1.40.20250701190355.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thds.core
-Version: 1.40.20250701001211
+Version: 1.40.20250701190355
 Summary: Core utilities.
 Author-email: Trilliant Health <info@trillianthealth.com>
 License: MIT

{thds_core-1.40.20250701001211.dist-info → thds_core-1.40.20250701190355.dist-info}/RECORD

@@ -1,21 +1,22 @@
-thds/core/__init__.py,sha256=Z-gAb4uuzXoFANJhJLaSZdfLuHaAGOcrf_6qwcue9Qo,938
+thds/core/__init__.py,sha256=BUX2dBk_xTCX-E_jXnDiIK4jxY97iOxEmwC1oRRz7Z4,955
 thds/core/ansi_esc.py,sha256=QZ3CptZbX4N_hyP2IgqfTbNt9tBPaqy7ReTMQIzGbrc,870
 thds/core/cache.py,sha256=nL0oAyZrhPqyBBLevnOWSWVoEBrftaG3aE6Qq6tvmAA,7153
 thds/core/calgitver.py,sha256=6ioH5MGE65l_Dp924oD5CWrLyxKgmhtn46YwGxFpHfM,2497
 thds/core/cm.py,sha256=WZB8eQU0DaBYj9s97nc3PuCtai9guovfyiQH68zhLzY,1086
 thds/core/concurrency.py,sha256=NQunF_tJ_z8cfVyhzkTPlb-nZrgu-vIk9_3XffgscKQ,3520
 thds/core/config.py,sha256=VWymw6pqPRvX7wwsJ0Y-D2gLoCclAHhARmTnuUw7kb0,10014
-thds/core/cpus.py,sha256=73eK_sttPrjDjWuVIlF2S3eO30S_5pUZiF1zxvTBxiY,3391
+thds/core/cpus.py,sha256=wcxNvcJaXfm7P-peLusbF5EhD0fGGt9tG_EeL5rbKU8,3836
 thds/core/decos.py,sha256=VpFTKTArXepICxN4U8C8J6Z5KDq-yVjFZQzqs2jeVAk,1341
 thds/core/dict_utils.py,sha256=MatsjZC9lchfdaDqNAzL2mkTZytDnCAqg56sMm71wbE,6364
+thds/core/dump_stacks.py,sha256=srE4VlgU1kwcMFf12skenSdinx7Lu174MjV-gLNh6n4,1033
 thds/core/env.py,sha256=HkuyFmGpCgdQUB1r2GbpCqB3cs1lCsvp47Ghk1DHBo8,1083
 thds/core/exit_after.py,sha256=0lz63nz2NTiIdyBDYyRa9bQShxQKe7eISy8VhXeW4HU,3485
 thds/core/files.py,sha256=NJlPXj7BejKd_Pa06MOywVv_YapT4bVedfsJHrWX8nI,4579
 thds/core/fretry.py,sha256=PKgOxCMjcF4zsFfXFvPXpomv5J6KU6llB1EaKukugig,6942
 thds/core/generators.py,sha256=rcdFpPj0NMJWSaSZTnBfTeZxTTORNB633Lng-BW1284,1939
 thds/core/git.py,sha256=cfdN1oXyfz7k7T2XaseTqL6Ng53B9lfKtzDLmFjojRs,2947
-thds/core/hash_cache.py,sha256=OKudAvqyaCzNRkhPAHbdHJKxHFxMRRyG3S1uFcq0jv4,3746
-thds/core/hashing.py,sha256=OqaV65vGKpT3l78jm-Uh7xG4DtAczGjk9-Q60OGmhY0,3521
+thds/core/hash_cache.py,sha256=jSFijG33UUQjVSkbuACdg4KzIBaf28i7hSQXCO49Qh0,4066
+thds/core/hashing.py,sha256=8UmbivijnFTzLu42zYsJSksogjrSEYrhzlKUjQBt8CM,4254
 thds/core/home.py,sha256=tTClL_AarIKeri1aNCpuIC6evD7qr83ESGD173B81hU,470
 thds/core/hostname.py,sha256=canFGr-JaaG7nUfsQlyL0JT-2tnZoT1BvXzyaOMK1vA,208
 thds/core/imports.py,sha256=0LVegY8I8_XKZPcqiIp2OVVzEDtyqYA3JETf9OAKNKs,568
@@ -25,7 +26,7 @@ thds/core/lazy.py,sha256=e1WvG4LsbEydV0igEr_Vl1cq05zlQNIE8MFYT90yglE,3289
 thds/core/link.py,sha256=kmFJIFvEZc16-7S7IGvtTpzwl3VuvFl3yPlE6WJJ03w,5404
 thds/core/logical_root.py,sha256=gWkIYRv9kNQfzbpxJaYiwNXVz1neZ2NvnvProtOn9d8,1399
 thds/core/merge_args.py,sha256=7oj7dtO1-XVkfTM3aBlq3QlZbo8tb6X7E3EVIR-60t8,5781
-thds/core/meta.py,sha256=BQls5UQpdVEd6mDlkYk8_c-k_OYkpvde9Doa_ATSrfA,12067
+thds/core/meta.py,sha256=3oX7wTO_SmrVKABFPLHHIVyNBXEil1MdGfc5s88_Isk,12134
 thds/core/parallel.py,sha256=HXAn9aIYqNE5rnRN5ypxR6CUucdfzE5T5rJ_MUv-pFk,7590
 thds/core/pickle_visit.py,sha256=QNMWIi5buvk2zsvx1-D-FKL7tkrFUFDs387vxgGebgU,833
 thds/core/prof.py,sha256=5ViolfPsAPwUTHuhAe-bon7IArPGXydpGoB5uZmObDk,8264
@@ -46,12 +47,12 @@ thds/core/log/json_formatter.py,sha256=C5bRsSbAqaQqfTm88jc3mYe3vwKZZLAxET8s7_u7a
 thds/core/log/kw_formatter.py,sha256=9-MVOd2r5NEkYNne9qWyFMeR5lac3w7mjHXsDa681i0,3379
 thds/core/log/kw_logger.py,sha256=CyZVPnkUMtrUL2Lyk261AIEPmoP-buf_suFAhQlU1io,4063
 thds/core/log/logfmt.py,sha256=i66zoG2oERnE1P_0TVXdlfJ1YgUmvtMjqRtdV5u2SvU,10366
-thds/core/source/__init__.py,sha256=0Zy3mwJgwLtc4jq14Cwu6d_Rq-aZOMIlu4zaADeKgmo,487
-thds/core/source/_construct.py,sha256=plSyQZRe8h0X7PpbfMjhm1qkFgrcyuSrReyWQo28YfA,3121
+thds/core/source/__init__.py,sha256=e-cRoLl1HKY3YrDjpV5p_i7zvr1L4q51-t1ISTxdig4,543
+thds/core/source/_construct.py,sha256=lt6OUOz_s9VBZMZJHXVpfIjmuTH7w1PBhpre0dlW1Zw,3914
 thds/core/source/_construct_tree.py,sha256=5Zk3a5a0uVxklWw6q4JOvI_bErqwlBngUz4TyEAWn1g,616
-thds/core/source/_download.py,sha256=d4MMcZllifXFfCyhSJgsPM9BIKRBd1D3GNjCA7gBveM,3059
-thds/core/source/serde.py,sha256=CPIVu6N-G-IhHiyZrNk4bQwYDTt8BUw31-TuwvkXoaw,3573
-thds/core/source/src.py,sha256=9A_8kSBUc5k6OLAYe5EW_VogpXFIqofow7Rxl8xv-eg,4559
+thds/core/source/_download.py,sha256=faKWxgzw1fTqOoyjtgi4IyhiZpBYTm_GZxwqC6LTiXU,2764
+thds/core/source/serde.py,sha256=zEAR24AewgDqqkIxcPpS7NZ-ZbEnQPK_A7siWlE3Q0E,3091
+thds/core/source/src.py,sha256=nTUBgsAES0J73enIEbc5BitgnxA5kBnf88oYZoMQGnM,4596
 thds/core/source/tree.py,sha256=iNCoCE655MwXQwc2Y0IIm1HMVk5Inj0NGVU9U8Wl_90,4317
 thds/core/sqlite/__init__.py,sha256=tDMzuO76qTtckJHldPQ6nPZ6kcvhhoJrVuuW42JtaSQ,606
 thds/core/sqlite/connect.py,sha256=l4QaSAI8RjP7Qh2FjmJ3EwRgfGf65Z3-LjtC9ocHM_U,977
@@ -68,8 +69,8 @@ thds/core/sqlite/structured.py,sha256=SvZ67KcVcVdmpR52JSd52vMTW2ALUXmlHEeD-VrzWV
 thds/core/sqlite/types.py,sha256=oUkfoKRYNGDPZRk29s09rc9ha3SCk2SKr_K6WKebBFs,1308
 thds/core/sqlite/upsert.py,sha256=BmKK6fsGVedt43iY-Lp7dnAu8aJ1e9CYlPVEQR2pMj4,5827
 thds/core/sqlite/write.py,sha256=z0219vDkQDCnsV0WLvsj94keItr7H4j7Y_evbcoBrWU,3458
-thds_core-1.40.20250701001211.dist-info/METADATA,sha256=xJjcbYqno7_Nx7yygvumTQC0aUjQpNChr7SXd_AlzjU,2216
-thds_core-1.40.20250701001211.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thds_core-1.40.20250701001211.dist-info/entry_points.txt,sha256=bOCOVhKZv7azF3FvaWX6uxE6yrjK6FcjqhtxXvLiFY8,161
-thds_core-1.40.20250701001211.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_core-1.40.20250701001211.dist-info/RECORD,,
+thds_core-1.40.20250701190355.dist-info/METADATA,sha256=0dIbr5SQsLbx0vRbK1R78no19nLyuBIa0dOCzoUA4RY,2216
+thds_core-1.40.20250701190355.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thds_core-1.40.20250701190355.dist-info/entry_points.txt,sha256=bOCOVhKZv7azF3FvaWX6uxE6yrjK6FcjqhtxXvLiFY8,161
+thds_core-1.40.20250701190355.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds_core-1.40.20250701190355.dist-info/RECORD,,