thds.core 1.44.20250722150732__py3-none-any.whl → 1.44.20250722163652__py3-none-any.whl

thds/core/__init__.py

@@ -13,7 +13,6 @@ from . import (  # noqa: F401
     exit_after,
     files,
     fretry,
-    futures,
     generators,
     git,
     hash_cache,

{thds_core-1.44.20250722150732.dist-info → thds_core-1.44.20250722163652.dist-info}/METADATA

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

{thds_core-1.44.20250722150732.dist-info → thds_core-1.44.20250722163652.dist-info}/RECORD

@@ -1,4 +1,4 @@
-thds/core/__init__.py,sha256=p5ZTz0yURvtiJlUspnI6aMb9nIekTkzU8sqr8HrnyiM,968
+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
@@ -14,7 +14,6 @@ thds/core/exit_after.py,sha256=0lz63nz2NTiIdyBDYyRa9bQShxQKe7eISy8VhXeW4HU,3485
 thds/core/files.py,sha256=NJlPXj7BejKd_Pa06MOywVv_YapT4bVedfsJHrWX8nI,4579
 thds/core/fp.py,sha256=S9hM7YmjbmaYbe4l5jSGnzf3HWhEaItmUOv6GMQpHo8,508
 thds/core/fretry.py,sha256=PKgOxCMjcF4zsFfXFvPXpomv5J6KU6llB1EaKukugig,6942
-thds/core/futures.py,sha256=JgqEP9TFC5UVr4tpfaVePHuI-pTsKAFHDWLxkE4aDb0,7372
 thds/core/generators.py,sha256=rcdFpPj0NMJWSaSZTnBfTeZxTTORNB633Lng-BW1284,1939
 thds/core/git.py,sha256=cfdN1oXyfz7k7T2XaseTqL6Ng53B9lfKtzDLmFjojRs,2947
 thds/core/hash_cache.py,sha256=jSFijG33UUQjVSkbuACdg4KzIBaf28i7hSQXCO49Qh0,4066
@@ -36,7 +35,6 @@ thds/core/progress.py,sha256=4YGbxliDl1i-k-88w4s86uy1E69eQ6xJySGPSkpH1QM,3358
 thds/core/project_root.py,sha256=K18U3MLthZnzmdrWmKKtHLd6iu7am9b2vNAThqknpfo,891
 thds/core/protocols.py,sha256=4na2EeWUDWfLn5-SxfMmKegDSndJ5z-vwMhDavhCpEM,409
 thds/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-thds/core/refcount.py,sha256=KWhF5vULrCUCJPoqh3X58JkbfYo8HmYpUrmCHjrUx64,4020
 thds/core/scaling.py,sha256=f7CtdgK0sN6nroTq5hLAkG8xwbWhbCZUULstSKjoxO0,1615
 thds/core/scope.py,sha256=9RWWCFRqsgjTyH6rzRm_WnO69N_sEBRaykarc2PAnBY,10834
 thds/core/source_serde.py,sha256=X4c7LiT3VidejqtTel9YB6dWGB3x-ct39KF9E50Nbx4,139
@@ -73,8 +71,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.44.20250722150732.dist-info/METADATA,sha256=Qz4IITKRw-rs7BobWBWWZNYEtcz4RAd6kXCyVT6H6wk,2216
-thds_core-1.44.20250722150732.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thds_core-1.44.20250722150732.dist-info/entry_points.txt,sha256=bOCOVhKZv7azF3FvaWX6uxE6yrjK6FcjqhtxXvLiFY8,161
-thds_core-1.44.20250722150732.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_core-1.44.20250722150732.dist-info/RECORD,,
+thds_core-1.44.20250722163652.dist-info/METADATA,sha256=wV2K6BylZOMJPiho5YLtWe8WXYVrG9I5lApfq81dxX8,2216
+thds_core-1.44.20250722163652.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thds_core-1.44.20250722163652.dist-info/entry_points.txt,sha256=bOCOVhKZv7azF3FvaWX6uxE6yrjK6FcjqhtxXvLiFY8,161
+thds_core-1.44.20250722163652.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds_core-1.44.20250722163652.dist-info/RECORD,,

thds/core/futures.py

@@ -1,227 +0,0 @@
-import concurrent.futures
-import typing as ty
-from dataclasses import dataclass
-from functools import partial
-
-from typing_extensions import ParamSpec
-
-from . import lazy
-
-R = ty.TypeVar("R")
-
-
-class PFuture(ty.Protocol[R]):
-    """
-    A Protocol defining the behavior of a future-like object.
-
-    This defines an interface for an object that acts as a placeholder
-    for a result that will be available later. It is structurally
-    compatible with concurrent.futures.Future but omits cancellation.
-    """
-
-    def running(self) -> bool:
-        """Return True if the future is currently executing."""
-        ...
-
-    def done(self) -> bool:
-        """Return True if the future is done (finished)."""
-        ...
-
-    def result(self, timeout: ty.Optional[float] = None) -> R:
-        """Return the result of the work item.
-
-        If the work item raised an exception, this method raises the same exception.
-        If the timeout is reached, it raises TimeoutError.
-        Other exceptions (e.g. CancelledException) may also be raised depending on the
-        implementation.
-        """
-        ...
-
-    def exception(self, timeout: ty.Optional[float] = None) -> ty.Optional[BaseException]:
-        """
-        Return the exception raised by the work item.
-
-        Returns None if the work item completed without raising.
-        If the timeout is reached, it raises TimeoutError.
-        Other exceptions (e.g. CancelledException) may also be raised depending on the
-        implementation.
-        """
-        ...
-
-    def add_done_callback(self, fn: ty.Callable[["PFuture[R]"], None]) -> None:
-        """
-        Attaches a callable that will be called when the future is done.
-
-        The callable will be called with the future object as its only
-        argument.
-        """
-        ...
-
-    def set_result(self, result: R) -> None:
-        """Set the result of the future, marking it as done."""
-        ...
-
-    def set_exception(self, exception: BaseException) -> None:
-        """Set the exception of the future, marking it as done."""
-        ...
-
-
-class LazyFuture(PFuture[R]):
-    def __init__(self, mk_future: ty.Callable[[], PFuture[R]]) -> None:
-        """mk_future should generally be serializable.
-
-        It also needs to be repeatable - i.e. if it were resolved in two different
-        processes, it should return the same 'result' (value or exception) in both.
-        """
-        self._mk_future = mk_future
-        self._lazy_future = lazy.lazy(mk_future)
-
-    def __getstate__(self) -> dict[str, ty.Any]:
-        """Return the state of the LazyFuture for serialization."""
-        return {"_mk_future": self._mk_future}
-
-    def __setstate__(self, state: dict[str, ty.Any]) -> None:
-        """Restore the state of the LazyFuture from serialization."""
-        self._mk_future = state["_mk_future"]
-        self._lazy_future = lazy.lazy(self._mk_future)
-
-    def running(self) -> bool:
-        """Return True if the future is currently executing."""
-        return self._lazy_future().running()
-
-    def done(self) -> bool:
-        """Return True if the future is done (finished)."""
-        return self._lazy_future().done()
-
-    def result(self, timeout: ty.Optional[float] = None) -> R:
-        """
-        Return the result of the work item.
-
-        If the work item raised an exception, this method raises the same
-        exception. If the timeout is reached, it raises TimeoutError.
-        """
-        return self._lazy_future().result(timeout)
-
-    def exception(self, timeout: ty.Optional[float] = None) -> ty.Optional[BaseException]:
-        """
-        Return the exception raised by the work item.
-
-        Returns None if the work item completed without raising.
-        If the timeout is reached, it raises TimeoutError.
-        """
-        return self._lazy_future().exception(timeout)
-
-    def add_done_callback(self, fn: ty.Callable[["PFuture[R]"], None]) -> None:
-        """
-        Attaches a callable that will be called when the future is done.
-
-        The callable will be called with the future object as its only
-        argument.
-        """
-        self._lazy_future().add_done_callback(fn)
-
-    def set_result(self, result: R) -> None:
-        """Set the result of the future, marking it as done."""
-        self._lazy_future().set_result(result)
-
-    def set_exception(self, exception: BaseException) -> None:
-        """Set the exception of the future, marking it as done."""
-        self._lazy_future().set_exception(exception)
-
-
-P = ParamSpec("P")
-
-
-def make_lazy(mk_future: ty.Callable[P, PFuture[R]]) -> ty.Callable[P, LazyFuture[R]]:
-    """Create a LazyFuture that will lazily resolve the given callable."""
-
-    def mk_future_with_params(*args: P.args, **kwargs: P.kwargs) -> LazyFuture[R]:
-        return LazyFuture(partial(mk_future, *args, **kwargs))
-
-    return mk_future_with_params
-
-
-@dataclass(frozen=True)
-class ResolvedFuture(PFuture[R]):
-    _result: R
-    _done: bool = True
-
-    def running(self) -> bool:
-        return False
-
-    def done(self) -> bool:
-        return self._done
-
-    def result(self, timeout: ty.Optional[float] = None) -> R:
-        return self._result
-
-    def exception(self, timeout: ty.Optional[float] = None) -> ty.Optional[BaseException]:
-        return None
-
-    def add_done_callback(self, fn: ty.Callable[["PFuture[R]"], None]) -> None:
-        fn(self)
-
-    def set_result(self, result: R) -> None:
-        raise RuntimeError("Cannot set result on a resolved future.")
-
-    def set_exception(self, exception: BaseException) -> None:
-        raise RuntimeError("Cannot set exception on a resolved future.")
-
-
-def resolved(result: R) -> ResolvedFuture[R]:
-    return ResolvedFuture(result)
-
-
-# what's below doesn't absolutely have to exist here, as it adds a 'dependency' on
-# concurrent.futures... but practically speaking I think that's a pretty safe default
-# 'actual Future' type.
-
-R1 = ty.TypeVar("R1")
-
-
-def identity(x: R) -> R:
-    return x
-
-
-def translate_done(
-    out_future: PFuture[R1],
-    translate_result: ty.Callable[[R], R1],
-    done_fut: PFuture[R],
-) -> None:
-    try:
-        result = done_fut.result()
-        out_future.set_result(translate_result(result))
-    except Exception as e:
-        out_future.set_exception(e)
-
-
-OF_R1 = ty.TypeVar("OF_R1", bound=PFuture)
-
-
-def chain_futures(
-    inner_future: PFuture[R],
-    outer_future: OF_R1,
-    translate_future: ty.Callable[[R], R1],
-) -> OF_R1:
-    """Chain two futures together with a translator in the middle."""
-    outer_done_cb = partial(translate_done, outer_future, translate_future)
-    inner_future.add_done_callback(outer_done_cb)
-    return outer_future
-
-
-def reify_future(future: PFuture[R]) -> concurrent.futures.Future[R]:
-    """Reify a PFuture into a concurrent.futures.Future."""
-    if isinstance(future, concurrent.futures.Future):
-        return future
-    return chain_futures(future, concurrent.futures.Future[R](), identity)
-
-
-def as_completed(
-    futures: ty.Iterable[PFuture[R]],
-) -> ty.Iterator[concurrent.futures.Future[R]]:
-    """Return an iterator that yields futures as they complete.
-
-    We do need to actually create Future objects here, using the add_done_callback method
-    so that the these things actually work with concurrent.futures.as_completed.
-    """
-    yield from concurrent.futures.as_completed(map(reify_future, futures))

thds/core/refcount.py

@@ -1,99 +0,0 @@
-"""There are times when what you want is a lazy-ish resource, but you don't want it to live forever - just for the duration of the current stack's usage.
-At the same time, if another thread or stack is currently using the resource, you want to reuse it.
-
-A good example of using this might be a ThreadPoolExecutor where multiple other threads might be doing similar work concurrently, and it would help if they could all share the same pool:
-
-```
-from concurrent.futures import ThreadPoolExecutor
-from thds.core import refcount
-
-
-shared_thread_pool = refcount.Resource(lambda: ThreadPoolExecutor())
-
-
-def do_work(thunks):
-    with shared_thread_pool.get() as thread_pool:
-        for res in parallel.yield_results(thunks, executor_cm=thread_pool):
-            print(res)
-        ...
-```
-"""
-
-import threading
-import typing as ty
-from contextlib import contextmanager
-
-from . import log
-
-R = ty.TypeVar("R")
-logger = log.getLogger(__name__)
-
-
-class _ContextProxy(ty.Generic[R]):
-    """A proxy to wrap a resource and neuter its context management methods."""
-
-    def __init__(self, resource: R):
-        self._resource = resource
-
-    def __getattr__(self, name: str) -> ty.Any:
-        return getattr(self._resource, name)
-
-    def __enter__(self) -> R:
-        # The user might still do `with proxy: ...`. We allow it,
-        # but it does nothing and just returns the underlying resource.
-        return self._resource
-
-    def __exit__(self, *args: ty.Any) -> None:
-        # This is a no-op; the real cleanup is handled by _RefCountResource
-        pass
-
-
-class _RefCountResource(ty.Generic[R]):
-    def __init__(self, factory: ty.Callable[[], ty.ContextManager[R]]) -> None:
-        self._factory = factory
-        self._rcm__exit__: ty.Optional[ty.Callable[[ty.Any, ty.Any, ty.Any], ty.Optional[bool]]] = None
-        self._resource: ty.Optional[R] = None
-        self._ref_count: int = 0
-        self._lock = threading.RLock()
-
-    @contextmanager
-    def get(self) -> ty.Iterator[R]:
-        with self._lock:
-            assert self._ref_count >= 0, "Reference count should not be negative prior to incrementing"
-            if self._ref_count == 0:
-                assert (
-                    self._rcm__exit__ is None
-                ), "Resource CM __exit__ should be None when ref count is zero"
-                assert self._resource is None, "Resource should be None when ref count is zero"
-                resource_cm = self._factory()
-                resource = resource_cm.__enter__()
-                self._rcm__exit__ = resource_cm.__exit__
-                if id(resource) == id(resource_cm):
-                    logger.info("Patching self-managing resource to avoid double exit: %s", resource)
-                    # this is one of those context managers that returns itself
-                    # since we manage this resource, we need to prevent others from trying to enter or exit it.
-                    resource = _ContextProxy(resource)  # type: ignore[assignment]
-                self._resource = resource
-            self._ref_count += 1
-            assert self._resource is not None, "Resource should not be None after incrementing ref count"
-            resource = self._resource
-        try:
-            yield resource
-
-        finally:
-            with self._lock:
-                self._ref_count -= 1
-                assert self._ref_count >= 0, "Reference count should not be negative after decrementing"
-                if self._ref_count == 0:
-                    assert (
-                        self._rcm__exit__ is not None
-                    ), "Resource CM __exit__ should not be None when ref count is zero"
-                    assert (
-                        self._resource is not None
-                    ), "Resource should not be None when ref count is zero"
-                    self._rcm__exit__(None, None, None)
-                    self._resource = None
-                    self._rcm__exit__ = None
-
-
-Resource = _RefCountResource  # probably preferable to use this name