stranded 0.0.1__py3-none-any.whl

stranded/argparse/threading/argument_parser_.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import inspect
+import typing
+
+from ...threading import composer_
+from ..abc import argument_parser_
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], argument_parser_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], argument_parser_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], argument_parser_.Exit[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], argument_parser_.Enter[ParamT, RetT]): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], argument_parser_.Composed[ParamT, RetT]):
+    def __call__(self, *argv: str) -> RetT:  # type: ignore[override]
+        ret = None
+        for call in super(composer_.Composed, self).__call__(*argv):
+            ret = call()
+            if inspect.iscoroutine(ret):
+                ret = asyncio.run(ret)
+        return ret  # type: ignore[return-value]
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class ArgumentParser[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], argument_parser_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+
+Composer = ArgumentParser
+argument_parser = ArgumentParser()

stranded/asyncio/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import composer_
+    from .composer_ import Composer
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'composer_': return _importlib.import_module('.composer_', __name__)
+        case 'Composer': return _importlib.import_module('.composer_', __name__).Composer
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'composer_',
+    'Composer',
+)

stranded/asyncio/composer_.py

@@ -0,0 +1,76 @@
+import abc
+import dataclasses
+import inspect
+import typing
+
+from ..abc import composer_
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+type ValueT[**ParamT_, RetT_] = composer_.ValueT[ParamT_, RetT_]
+type StackT = tuple[
+    ValueT[typing.Any, typing.Any]
+    | Composee[typing.Any, typing.Any]
+    | Connect[typing.Any, typing.Any]
+    | Exit[typing.Any, typing.Any]
+    | Enter[typing.Any, typing.Any]
+    | Composed[typing.Any, typing.Any],
+    ...,
+]
+
+
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], typing.Protocol):
+    async def __call__(*args: ParamT.args, **kwargs: ParamT.kwargs) -> RetT: ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], abc.ABC):
+    async def __call__(self, value: ValueT[ParamT, RetT], /) -> StackT: return super().__call__(value)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], abc.ABC):
+    async def __call__(self, value: ValueT[ParamT, RetT], /) -> StackT: return super().__call__(value)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], abc.ABC):
+    async def __call__(self, value: ValueT[ParamT, RetT], /) -> StackT: return super().__call__(value)
+
+
+@inspect.markcoroutinefunction
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], abc.ABC):
+    async def __call__(self, *args: ParamT.args, **kwargs: ParamT.kwargs) -> RetT:
+        value: Param[ParamT] | Raise | Return[RetT] | Stop = Param(args=args, kwargs=kwargs)
+        stack = list(self.stack)
+        while stack:
+            match stack.pop():
+                case Param() | Raise() | Return() | Stop() as value_: value = value_
+                case Enter() | Exit() | Connect() as get_stack_: stack += await get_stack_(value)
+                case Composed() as composed_ if isinstance(value, Param): stack += composed_.stack
+                case composee_ if isinstance(value, Param):
+                    try:
+                        value = Return(ret=await composee_(*value.args, **value.kwargs))
+                    except Stop as stopped_:
+                        value = stopped_
+                    except Exception as exception_:
+                        value = Raise(exc_type=type(exception_), exc_val=exception_, exc_tb=exception_.__traceback__)
+
+        match value:
+            case Stop() as stop_: raise stop_
+            case Raise() as raise_: raise raise_.exc_val
+            case Return() as return_: return return_.ret  # type: ignore[no-any-return]
+            case _: raise Exception(f'{type(self).__name__} call completed with invalid {value=!r}')
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composer[**ParamT, RetT](composer_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed

stranded/builtins/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import exception_
+    from .exception_ import Exception
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'exception_': return _importlib.import_module('.exception_', __name__)
+        case 'Exception': return _importlib.import_module('.exception_', __name__).Exception
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'exception_',
+    'Exception',
+)

stranded/builtins/exception_.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+import builtins
+
+
+class Exception(builtins.Exception): ...  # noqa

stranded/composer_.py

@@ -0,0 +1,27 @@
+import dataclasses
+import importlib
+import inspect
+import typing
+
+from .abc import composer_
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composer[**ParamT, RetT](composer_.Composer[ParamT, RetT]):
+    # Stub bindings for the agnostic dispatcher — never instantiated, since
+    # __call__ delegates to the asyncio/threading concrete Composer.
+    Composee: typing.ClassVar = composer_.Composee
+    Connect: typing.ClassVar = composer_.Connect
+    Exit: typing.ClassVar = composer_.Exit
+    Enter: typing.ClassVar = composer_.Enter
+    Composed: typing.ClassVar = composer_.Composed
+
+    def __call__[ComposeeT](self, composee: ComposeeT) -> ComposeeT:  # type: ignore[override]
+        (name_parts := self.__module__.split('.')).insert(
+            -1,
+            'asyncio' if inspect.iscoroutinefunction(composee) else 'threading'
+        )
+
+        return importlib.import_module(  # type: ignore[no-any-return]
+            name='.'.join(name_parts),
+        ).Composer(**dataclasses.asdict(self))(composee)  # noqa

stranded/execution/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import abc
+    from . import asyncio
+    from . import scheduler_
+    from .scheduler_ import Scheduler
+    from . import threading
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'abc': return _importlib.import_module('.abc', __name__)
+        case 'asyncio': return _importlib.import_module('.asyncio', __name__)
+        case 'scheduler_': return _importlib.import_module('.scheduler_', __name__)
+        case 'Scheduler': return _importlib.import_module('.scheduler_', __name__).Scheduler
+        case 'threading': return _importlib.import_module('.threading', __name__)
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'abc',
+    'asyncio',
+    'scheduler_',
+    'Scheduler',
+    'threading',
+)

stranded/execution/abc/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import scheduler_
+    from .scheduler_ import Scheduler
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'scheduler_': return _importlib.import_module('.scheduler_', __name__)
+        case 'Scheduler': return _importlib.import_module('.scheduler_', __name__).Scheduler
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'scheduler_',
+    'Scheduler',
+)

stranded/execution/abc/scheduler_.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import abc
+import dataclasses
+import typing
+
+from ...abc import composer_
+from ...builtins import exception_
+
+
+class Exception(exception_.Exception): ...  # noqa
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], abc.ABC): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], abc.ABC): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], abc.ABC): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], abc.ABC): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Scheduler[**ParamT, RetT](composer_.Composer[ParamT, RetT], abc.ABC):
+    # A Scheduler is its own ergonomic composer: the wrapped Composee keeps the
+    # callee's call signature. The composition machinery still receives the real
+    # Composed produced by Composer.__call__.
+    def __call__[ComposeeT](self, composee: ComposeeT, /) -> ComposeeT:  # type: ignore[override]
+        return typing.cast(
+            'ComposeeT',
+            super().__call__(typing.cast('composer_.Composee[typing.Any, typing.Any]', composee)),
+        )
+
+    @abc.abstractmethod
+    def submit_sync(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any: ...
+
+    @abc.abstractmethod
+    async def submit_async(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any: ...

stranded/execution/asyncio/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import scheduler_
+    from .scheduler_ import Scheduler
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'scheduler_': return _importlib.import_module('.scheduler_', __name__)
+        case 'Scheduler': return _importlib.import_module('.scheduler_', __name__).Scheduler
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'scheduler_',
+    'Scheduler',
+)

stranded/execution/asyncio/scheduler_.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import inspect
+import typing
+
+from ...asyncio import composer_
+from ..abc import scheduler_
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], scheduler_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], scheduler_.Connect[ParamT, RetT]): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], scheduler_.Exit[ParamT, RetT]): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], scheduler_.Enter[ParamT, RetT]):
+    @typing.overload  # type: ignore[override]
+    async def __call__(self, value: Param[ParamT], /) -> tuple[composer_.Exit[ParamT, RetT], composer_.Composee[ParamT, RetT]]: ...
+    @typing.overload
+    async def __call__(self, value: Raise | Return[RetT] | Stop, /) -> tuple[()]: ...
+    async def __call__(
+        self, value: Param[ParamT] | Raise | Return[RetT] | Stop, /,
+    ) -> tuple[composer_.Exit[ParamT, RetT], composer_.Composee[ParamT, RetT]] | tuple[()]:
+        if not isinstance(value, Param):
+            return ()
+        scheduler: Scheduler[ParamT, RetT] = typing.cast('Scheduler[ParamT, RetT]', self.composer)
+        inner = self.composee
+
+        async def wrapped(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            return await scheduler.submit_async(inner, args, kwargs)
+
+        return self.composer.Exit(enter=self), typing.cast(composer_.Composee[ParamT, RetT], wrapped)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], scheduler_.Composed[ParamT, RetT]): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Scheduler[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], scheduler_.Scheduler[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+    loop: asyncio.AbstractEventLoop | None = None
+
+    def submit_sync(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any:
+        if inspect.iscoroutinefunction(fn):
+            return asyncio.run(fn(*args, **kwargs))
+        return fn(*args, **kwargs)
+
+    async def submit_async(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any:
+        if inspect.iscoroutinefunction(fn):
+            coro = fn(*args, **kwargs)
+            if self.loop is None or self.loop is asyncio.get_running_loop():
+                return await asyncio.ensure_future(coro)
+            future = asyncio.run_coroutine_threadsafe(coro, self.loop)
+            return await asyncio.wrap_future(future)
+        return fn(*args, **kwargs)

stranded/execution/scheduler_.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import importlib
+import inspect
+import typing
+
+from ..abc import composer_
+from .abc import scheduler_
+
+
+def _dispatch(self: scheduler_.Scheduler[typing.Any, typing.Any], target: typing.Any) -> typing.Any:
+    flavor = 'asyncio' if inspect.iscoroutinefunction(target) else 'threading'
+    parts = type(self).__module__.split('.')
+    parts.insert(-1, flavor)
+    module = importlib.import_module('.'.join(parts))
+    cls = getattr(module, type(self).__name__)
+    target_field_names = {f.name for f in dataclasses.fields(cls)}
+    kwargs = {
+        f.name: getattr(self, f.name)
+        for f in dataclasses.fields(self)
+        if f.name in target_field_names
+    }
+    return cls(**kwargs)(target)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Scheduler[**ParamT, RetT](scheduler_.Scheduler[ParamT, RetT]):
+    Composee: typing.ClassVar = composer_.Composee
+    Connect: typing.ClassVar = composer_.Connect
+    Exit: typing.ClassVar = composer_.Exit
+    Enter: typing.ClassVar = composer_.Enter
+    Composed: typing.ClassVar = composer_.Composed
+
+    # Union of flavor-specific fields. The dispatcher forwards only the fields
+    # the target flavor's Scheduler actually accepts.
+    max_workers: int | None = None
+    thread_name_prefix: str = 'stranded'
+    loop: asyncio.AbstractEventLoop | None = None
+
+    def submit_sync(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any:
+        raise NotImplementedError
+
+    async def submit_async(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any:
+        raise NotImplementedError
+
+    def __call__[ComposeeT](self, target: ComposeeT) -> ComposeeT:  # type: ignore[override]
+        return _dispatch(self, target)

stranded/execution/threading/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import scheduler_
+    from .scheduler_ import Scheduler
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'scheduler_': return _importlib.import_module('.scheduler_', __name__)
+        case 'Scheduler': return _importlib.import_module('.scheduler_', __name__).Scheduler
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'scheduler_',
+    'Scheduler',
+)

stranded/execution/threading/scheduler_.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import asyncio
+import atexit
+import concurrent.futures
+import dataclasses
+import functools
+import inspect
+import typing
+
+from ...threading import composer_
+from ..abc import scheduler_
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], scheduler_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], scheduler_.Connect[ParamT, RetT]): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], scheduler_.Exit[ParamT, RetT]): ...
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], scheduler_.Enter[ParamT, RetT]):
+    @typing.overload  # type: ignore[override]
+    def __call__(self, value: Param[ParamT], /) -> tuple[composer_.Exit[ParamT, RetT], composer_.Composee[ParamT, RetT]]: ...
+    @typing.overload
+    def __call__(self, value: Raise | Return[RetT] | Stop, /) -> tuple[()]: ...
+    def __call__(
+        self, value: Param[ParamT] | Raise | Return[RetT] | Stop, /,
+    ) -> tuple[composer_.Exit[ParamT, RetT], composer_.Composee[ParamT, RetT]] | tuple[()]:
+        if not isinstance(value, Param):
+            return ()
+        scheduler: Scheduler[ParamT, RetT] = typing.cast('Scheduler[ParamT, RetT]', self.composer)
+        inner = self.composee
+
+        def wrapped(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            return scheduler.submit_sync(inner, args, kwargs)
+
+        return self.composer.Exit(enter=self), typing.cast(composer_.Composee[ParamT, RetT], wrapped)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], scheduler_.Composed[ParamT, RetT]): ...
+
+
+_thread_pools: dict[tuple[int | None, str], concurrent.futures.ThreadPoolExecutor] = {}
+
+
+def _shared_thread_pool(
+    max_workers: int | None,
+    thread_name_prefix: str,
+) -> concurrent.futures.ThreadPoolExecutor:
+    key = (max_workers, thread_name_prefix)
+    pool = _thread_pools.get(key)
+    if pool is None:
+        pool = concurrent.futures.ThreadPoolExecutor(
+            max_workers=max_workers,
+            thread_name_prefix=thread_name_prefix,
+        )
+        _thread_pools[key] = pool
+    return pool
+
+
+def _shutdown_all() -> None:
+    for pool in _thread_pools.values():
+        pool.shutdown(wait=False)
+    _thread_pools.clear()
+
+
+atexit.register(_shutdown_all)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Scheduler[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], scheduler_.Scheduler[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+    max_workers: int | None = None
+    thread_name_prefix: str = 'stranded'
+
+    def submit_sync(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any:
+        pool = _shared_thread_pool(self.max_workers, self.thread_name_prefix)
+        return pool.submit(fn, *args, **kwargs).result()
+
+    async def submit_async(
+        self,
+        fn: typing.Callable[..., typing.Any],
+        args: tuple[typing.Any, ...],
+        kwargs: dict[str, typing.Any],
+    ) -> typing.Any:
+        loop = asyncio.get_running_loop()
+        pool = _shared_thread_pool(self.max_workers, self.thread_name_prefix)
+        if inspect.iscoroutinefunction(fn):
+            def runner() -> typing.Any:
+                return asyncio.run(fn(*args, **kwargs))
+            return await loop.run_in_executor(pool, runner)
+        return await loop.run_in_executor(pool, functools.partial(fn, *args, **kwargs))

stranded/functools/__init__.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import herd_
+    from .herd_ import Herd
+    from .herd_ import herd
+    from . import lru_cache_
+    from .lru_cache_ import LruCache
+    from .lru_cache_ import lru_cache
+    from . import retry_
+    from .retry_ import Retry
+    from .retry_ import retry
+    from . import throttle_
+    from .throttle_ import Throttle
+    from .throttle_ import throttle
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'herd_': return _importlib.import_module('.herd_', __name__)
+        case 'Herd': return _importlib.import_module('.herd_', __name__).Herd
+        case 'herd': return _importlib.import_module('.herd_', __name__).herd
+        case 'lru_cache_': return _importlib.import_module('.lru_cache_', __name__)
+        case 'LruCache': return _importlib.import_module('.lru_cache_', __name__).LruCache
+        case 'lru_cache': return _importlib.import_module('.lru_cache_', __name__).lru_cache
+        case 'retry_': return _importlib.import_module('.retry_', __name__)
+        case 'Retry': return _importlib.import_module('.retry_', __name__).Retry
+        case 'retry': return _importlib.import_module('.retry_', __name__).retry
+        case 'throttle_': return _importlib.import_module('.throttle_', __name__)
+        case 'Throttle': return _importlib.import_module('.throttle_', __name__).Throttle
+        case 'throttle': return _importlib.import_module('.throttle_', __name__).throttle
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'herd_',
+    'Herd',
+    'herd',
+    'lru_cache_',
+    'LruCache',
+    'lru_cache',
+    'retry_',
+    'Retry',
+    'retry',
+    'throttle_',
+    'Throttle',
+    'throttle',
+)