stranded 0.0.1__py3-none-any.whl

stranded/functools/asyncio/lru_cache_.py

@@ -0,0 +1,92 @@
+import asyncio
+import dataclasses
+import typing
+
+from ..abc import lru_cache_
+from ...asyncio import composer_
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], lru_cache_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Future[RetT](lru_cache_.Future[RetT]):
+    future: asyncio.Future[RetT] = dataclasses.field(default_factory=asyncio.Future)
+
+    @typing.override
+    def set_value(self, value: Return[RetT] | Raise | Stop) -> None:
+        match value:
+            case Return(ret=ret): self.future.set_result(ret)
+            case Raise() as raise_: self.future.set_exception(raise_.exc_val)
+            case Stop() as stop_: self.future.set_exception(stop_)
+
+    @typing.override
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> RetT:
+        return await self.future
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], lru_cache_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], lru_cache_.Exit[ParamT, RetT, Future[RetT]]):
+    @typing.override
+    async def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:  # type: ignore[override]
+        match value:
+            case Param(): pass
+            case Return() | Raise() | Stop(): self.future.set_value(value)
+
+        return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], lru_cache_.Enter[ParamT, RetT, Future[RetT]]):
+    # TODO: Dedup this with the threading version.
+    @typing.override
+    async def __call__(  # type: ignore[override]
+        self, value: composer_.ValueT[ParamT, RetT], /,
+    ) -> composer_.StackT:
+        match value:
+            case Param():
+                key = self.create_key(*value.args, **value.kwargs)
+                if (future := self.get_future(key)) is not None:
+                    return future,
+                future = self.set_future(key)
+                return self.composer.Exit(enter=self, future=future, key=key), self.composee  # type: ignore[call-arg, return-value]
+            case _: return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], lru_cache_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class LruCache[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], lru_cache_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit  # type: ignore[assignment]
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+    @property
+    @typing.override
+    def future_t(self) -> type[Future[RetT]]:
+        return Future
+
+
+Composer = LruCache
+lru_cache = LruCache()

stranded/functools/asyncio/retry_.py

@@ -0,0 +1,43 @@
+import dataclasses
+import typing
+
+from ..abc import retry_
+from ...asyncio import composer_
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], retry_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], retry_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], retry_.Exit[ParamT, RetT]): ...  # type: ignore[misc]
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], retry_.Enter[ParamT, RetT]): ...  # type: ignore[misc]
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], retry_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Retry[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], retry_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+
+Composer = Retry
+retry = Retry()

stranded/functools/asyncio/throttle_.py

@@ -0,0 +1,74 @@
+import asyncio
+import dataclasses
+import typing
+
+from ..abc import throttle_
+from ...asyncio import composer_
+
+type _Condition = asyncio.Condition
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], throttle_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+Param = composer_.Param
+Raise = composer_.Raise
+Return = composer_.Return
+Stop = composer_.Stop
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], throttle_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], throttle_.Exit[ParamT, RetT]):
+    async def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:  # type: ignore[override]
+        async with self.enter.condition:  # type: ignore[attr-defined]
+            return await super().__call__(value)
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], throttle_.Enter[ParamT, RetT]):
+    condition: _Condition = dataclasses.field(default_factory=asyncio.Condition)
+
+    async def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:  # type: ignore[override]
+        # TODO: this is mostly duplicate with the threading version. Try to consolidate.
+        match value:
+            case Param():
+                state = self.state
+                async with self.condition:
+                    if state.num_waiting >= self.composer.max_waiting:  # type: ignore[attr-defined]
+                        raise Exception(f'Exceeded {self.composer.max_waiting=}.')  # type: ignore[attr-defined]
+                    elif 0 < state.num_waiting or state.cap_running <= state.num_running:
+                        state.num_waiting += 1
+                        await self.condition.wait_for(lambda: state.num_running < state.cap_running)
+                        state.num_waiting -= 1
+                    state.num_running += 1
+
+                return self.composer.Exit(enter=self), self.composee,  # type: ignore[return-value]
+            case _:
+                return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], throttle_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Throttle[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], throttle_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+
+Composer = Throttle
+throttle = Throttle()

stranded/functools/herd_.py

@@ -0,0 +1,18 @@
+import dataclasses
+import typing
+
+from .abc import herd_
+from .. import composer_
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Herd(composer_.Composer[..., typing.Any], herd_.Herd[..., typing.Any]):
+    @property
+    def future_t(self) -> type:
+        raise NotImplementedError(
+            f'{type(self).__name__} is a dispatcher; future_t is provided by the threading or asyncio variant.'
+        )
+
+
+Composer = Herd
+herd = Herd()

stranded/functools/lru_cache_.py

@@ -0,0 +1,18 @@
+import dataclasses
+import typing
+
+from .abc import lru_cache_
+from .. import composer_
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class LruCache(composer_.Composer[..., typing.Any], lru_cache_.LruCache[..., typing.Any]):
+    @property
+    def future_t(self) -> type:
+        raise NotImplementedError(
+            f'{type(self).__name__} is a dispatcher; future_t is provided by the threading or asyncio variant.'
+        )
+
+
+Composer = LruCache
+lru_cache = LruCache()

stranded/functools/retry_.py

@@ -0,0 +1,13 @@
+import dataclasses
+import typing
+
+from .abc import retry_
+from .. import composer_
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Retry(composer_.Composer[..., typing.Any], retry_.Retry[..., typing.Any]): ...
+
+
+Composer = Retry
+retry = Retry()

stranded/functools/threading/__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',
+)

stranded/functools/threading/herd_.py

@@ -0,0 +1,88 @@
+import concurrent.futures
+import dataclasses
+import typing
+
+from ..abc import herd_
+from ...threading import composer_
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], herd_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Future[RetT](herd_.Future[RetT]):
+    future: concurrent.futures.Future[RetT] = dataclasses.field(default_factory=concurrent.futures.Future)
+
+    @typing.override
+    def set_value(self, value: Return[RetT] | Raise | Stop) -> None:
+        match value:
+            case Return(ret=ret): self.future.set_result(ret)
+            case Raise() as raise_: self.future.set_exception(raise_.exc_val)
+            case Stop() as stop_: self.future.set_exception(stop_)
+
+    @typing.override
+    def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> RetT:
+        return self.future.result()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], herd_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], herd_.Exit[ParamT, RetT, Future[RetT]]):
+    future: Future[RetT] = dataclasses.field(default_factory=Future)
+
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        self.enter.future_by_key.pop(self.key, None)  # type: ignore[attr-defined]
+        match value:
+            case Param(): pass
+            case Return() | Raise() | Stop(): self.future.set_value(value)
+
+        return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], herd_.Enter[ParamT, RetT, Future[RetT]]):
+    @typing.override
+    def __call__(
+        self, value: composer_.ValueT[ParamT, RetT], /,
+    ) -> composer_.StackT:
+        match value:
+            case Param(): return self._dispatch(*value.args, **value.kwargs)  # type: ignore[return-value]
+            case _: return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], herd_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Herd[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], herd_.Herd[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit  # type: ignore[assignment]
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+    @property
+    @typing.override
+    def future_t(self) -> type[Future[RetT]]:
+        return Future
+
+
+Composer = Herd
+herd = Herd()

stranded/functools/threading/lru_cache_.py

@@ -0,0 +1,90 @@
+import concurrent.futures
+import dataclasses
+import typing
+
+from ..abc import lru_cache_
+from ...threading import composer_
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], lru_cache_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Future[RetT](lru_cache_.Future[RetT]):
+    future: concurrent.futures.Future[RetT] = dataclasses.field(default_factory=concurrent.futures.Future)
+
+    @typing.override
+    def set_value(self, value: Return[RetT] | Raise | Stop) -> None:
+        match value:
+            case Return(ret=ret): self.future.set_result(ret)
+            case Raise() as raise_: self.future.set_exception(raise_.exc_val)
+            case Stop() as stop_: self.future.set_exception(stop_)
+
+    @typing.override
+    def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> RetT:
+        return self.future.result()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], lru_cache_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], lru_cache_.Exit[ParamT, RetT, Future[RetT]]):
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        match value:
+            case Param(): pass
+            case Return() | Raise() | Stop(): self.future.set_value(value)
+
+        return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], lru_cache_.Enter[ParamT, RetT, Future[RetT]]):
+    # TODO: Dedup this with the asyncio version.
+    def __call__(
+        self, value: composer_.ValueT[ParamT, RetT], /,
+    ) -> composer_.StackT:
+        match value:
+            case Param():
+                key = self.create_key(*value.args, **value.kwargs)
+                if (future := self.get_future(key)) is not None:
+                    return future,
+                future = self.set_future(key)
+                return self.composer.Exit(enter=self, future=future, key=key), self.composee  # type: ignore[call-arg, return-value]
+            case _: return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], lru_cache_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class LruCache[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], lru_cache_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit  # type: ignore[assignment]
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+    @property
+    @typing.override
+    def future_t(self) -> type[Future[RetT]]:
+        return Future
+
+
+Composer = LruCache
+lru_cache = LruCache()

stranded/functools/threading/retry_.py

@@ -0,0 +1,42 @@
+import dataclasses
+import typing
+
+from ..abc import retry_
+from ...threading import composer_
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], retry_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], retry_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], retry_.Exit[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], retry_.Enter[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], retry_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Retry[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], retry_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+
+Composer = Retry
+retry = Retry()

stranded/functools/threading/throttle_.py

@@ -0,0 +1,75 @@
+import dataclasses
+import threading
+import typing
+
+from ...threading import composer_
+from ..abc import throttle_
+
+
+type _Condition = threading.Condition
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], throttle_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+Param = composer_.Param
+Raise = composer_.Raise
+Return = composer_.Return
+Stop = composer_.Stop
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], throttle_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], throttle_.Exit[ParamT, RetT]):
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        with self.enter.condition:  # type: ignore[attr-defined]
+            return super().__call__(value)
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], throttle_.Enter[ParamT, RetT]):
+    condition: _Condition = dataclasses.field(default_factory=threading.Condition)
+
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        # TODO: this is mostly duplicate with the asyncio version. Try to consolidate.
+        match value:
+            case Param():
+                state = self.state
+                with self.condition:
+                    if state.num_waiting >= self.composer.max_waiting:  # type: ignore[attr-defined]
+                        raise Exception(f'Exceeded {self.composer.max_waiting=}.')  # type: ignore[attr-defined]
+                    elif 0 < state.num_waiting or state.cap_running <= state.num_running:
+                        state.num_waiting += 1
+                        self.condition.wait_for(lambda: state.num_running < state.cap_running)
+                        state.num_waiting -= 1
+                    state.num_running += 1
+
+                return self.composer.Exit(enter=self), self.composee,  # type: ignore[return-value]
+            case _:
+                return ()
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], throttle_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Throttle[**ParamT = ..., RetT = typing.Any](composer_.Composer[ParamT, RetT], throttle_.Composer[ParamT, RetT]):
+    Composee: typing.ClassVar = Composee
+    Connect: typing.ClassVar = Connect
+    Exit: typing.ClassVar = Exit
+    Enter: typing.ClassVar = Enter
+    Composed: typing.ClassVar = Composed
+
+
+Composer = Throttle
+throttle = Throttle()

stranded/functools/throttle_.py

@@ -0,0 +1,13 @@
+import dataclasses
+import typing
+
+from .abc import throttle_
+from .. import composer_
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Throttle(composer_.Composer[..., typing.Any], throttle_.Throttle[..., typing.Any]): ...
+
+
+Composer = Throttle
+throttle = Throttle()

stranded/logging/__init__.py

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

stranded/logging/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 logger_
+    from .logger_ import Logger
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'logger_': return _importlib.import_module('.logger_', __name__)
+        case 'Logger': return _importlib.import_module('.logger_', __name__).Logger
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'logger_',
+    'Logger',
+)