stranded 0.0.1__py3-none-any.whl

stranded/logging/abc/logger_.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import abc
+import dataclasses
+import inspect
+import logging
+import typing
+
+from ...abc import composer_
+from ...builtins import exception_
+
+
+Level = typing.Literal['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'NOTSET']
+
+
+class Exception(exception_.Exception): ...  # noqa
+
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+Param = composer_.Param
+Raise = composer_.Raise
+Return = composer_.Return
+Stop = composer_.Stop
+
+
+@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):
+    bound_arguments: inspect.BoundArguments
+
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        match value:
+            case Raise() as raise_:
+                logging.getLogger(f'{self.enter.composee.__module__}.{self.enter.composee.__name__}').log(
+                    logging.getLevelNamesMapping()[self.enter.composer.exception_level],  # type: ignore[attr-defined]
+                    '%s :: %s !! %s',
+                    inspect.signature(self.enter.composee),
+                    self.bound_arguments.arguments,
+                    raise_.exc_val,
+                )
+            case Return(ret=ret):
+                level = (
+                    self.enter.composer.none_level  # type: ignore[attr-defined]
+                    if ret is None
+                    else self.enter.composer.return_level  # type: ignore[attr-defined]
+                )
+                logging.getLogger(f'{self.enter.composee.__module__}.{self.enter.composee.__name__}').log(
+                    logging.getLevelNamesMapping()[level],
+                    '%s :: %s -> %s',
+                    inspect.signature(self.enter.composee),
+                    self.bound_arguments.arguments,
+                    ret,
+                )
+
+        return ()
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], abc.ABC):
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        match value:
+            case Param() as param_:
+                bound_arguments = inspect.signature(self.composee).bind(*param_.args, **param_.kwargs)
+
+                logging.getLogger(f'{self.composee.__module__}.{self.composee.__name__}').log(
+                    logging.getLevelNamesMapping()[self.composer.call_level],  # type: ignore[attr-defined]
+                    '%s',
+                    bound_arguments,
+                )
+
+                return self.composer.Exit(enter=self, bound_arguments=bound_arguments), self.composee,  # type: ignore[call-arg]
+            case _:
+                return ()
+
+
+@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 Logger[**ParamT, RetT](composer_.Composer[ParamT, RetT], abc.ABC):
+    call_level: Level = 'DEBUG'
+    exception_level: Level = 'ERROR'
+    none_level: Level = 'WARNING'
+    return_level: Level = 'INFO'
+
+    Level: typing.ClassVar[type[Level]] = Level  # type: ignore[assignment, valid-type]
+
+
+Composer = Logger

stranded/logging/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 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',
+)

stranded/logging/asyncio/logger_.py

@@ -0,0 +1,41 @@
+import dataclasses
+import typing
+
+from ...asyncio import composer_
+from ..abc import logger_
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], logger_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], logger_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], logger_.Exit[ParamT, RetT]): ...  # type: ignore[misc]
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], logger_.Enter[ParamT, RetT]): ...  # type: ignore[misc]
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], logger_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Logger[**ParamT, RetT](composer_.Composer[ParamT, RetT], logger_.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
+
+
+Composer = Logger

stranded/logging/logger_.py

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

stranded/logging/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 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',
+)

stranded/logging/threading/logger_.py

@@ -0,0 +1,41 @@
+import dataclasses
+import typing
+
+from ...threading import composer_
+from ..abc import logger_
+
+@typing.runtime_checkable
+class Composee[**ParamT, RetT](composer_.Composee[ParamT, RetT], logger_.Composee[ParamT, RetT], typing.Protocol): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Connect[**ParamT, RetT](composer_.Connect[ParamT, RetT], logger_.Connect[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Exit[**ParamT, RetT](composer_.Exit[ParamT, RetT], logger_.Exit[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], logger_.Enter[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], logger_.Composed[ParamT, RetT]): ...
+
+
+@typing.final
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Logger[**ParamT, RetT](composer_.Composer[ParamT, RetT], logger_.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
+
+
+Composer = Logger

stranded/sqlite3/__init__.py

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

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

stranded/sqlite3/abc/db_.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import abc
+import ast
+import dataclasses
+import inspect
+import pathlib
+import sqlite3
+import threading
+import typing
+
+from ...abc import composer_
+
+type GenerateKey = typing.Callable[..., Key]
+type Key = typing.Hashable
+
+
+Raise = composer_.Raise
+Stop = composer_.Stop
+Param = composer_.Param
+Return = composer_.Return
+
+
+@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):
+    key: str
+
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        match value:
+            case Param() | Raise() | Stop(): pass
+            case Return():
+                assert self.enter.composer.deserialize(  # type: ignore[attr-defined]
+                    ret := self.enter.composer.serialize(value.ret)  # type: ignore[attr-defined]
+                ) == value.ret, 'Return value must be deserializable from its serialized form.'
+
+                with self.enter.lock:  # type: ignore[attr-defined]
+                    self.enter.connection.execute(  # type: ignore[attr-defined]
+                        f'INSERT INTO `{self.enter.table_name}` (key, ret) VALUES (?, ?)',  # type: ignore[attr-defined]
+                        (self.key, ret,)
+                    )
+
+        return ()
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Enter[**ParamT, RetT](composer_.Enter[ParamT, RetT], abc.ABC):
+    # The connection and its per-composition metadata live on the Enter now that
+    # Enter/Exit no longer reach Composed.
+    connection: sqlite3.Connection
+    instance: composer_.Instance
+    table_name: str
+    lock: threading.Lock = dataclasses.field(default_factory=threading.Lock)
+
+    def __call__(self, value: composer_.ValueT[ParamT, RetT], /) -> composer_.StackT:
+        match value:
+            case Raise() | Return() | Stop(): return ()
+            case Param():
+                (bound := inspect.signature(self.composee).bind(*value.args, **value.kwargs)).apply_defaults()
+                key = repr((self.instance, bound.args, tuple(sorted(bound.kwargs))))
+
+                with self.lock:
+                    ret = self.connection.execute(
+                        f'SELECT ret FROM `{self.table_name}` WHERE key = ?',
+                        (key,),
+                    ).fetchone()
+                if ret:
+                    return Return(ret=self.composer.deserialize(ret[0])),  # type: ignore[attr-defined]
+
+                return self.composer.Exit(enter=self, key=key), self.composee,  # type: ignore[call-arg]
+
+        raise ValueError(f'Invalid {value=}')
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], abc.ABC):
+    def __get__(self, instance: composer_.Instance, owner: type[object] | None) -> typing.Self:
+        match self.stack[-1]:
+            case Enter() as enter_:
+                return dataclasses.replace(
+                    self,
+                    stack=(
+                        *self.stack[:-1],
+                        dataclasses.replace(
+                            enter_, composee=enter_.composee.__get__(instance, owner), instance=instance,
+                        ),
+                    ),
+                )
+        assert False, "unreachable"
+
+
+# Aliases for annotation use. The Db ClassVars below shadow the class names within
+# Db's scope, so annotations must reference these instead.
+type ComposeeT[**ParamT, RetT] = Composee[ParamT, RetT]
+type ConnectT[**ParamT, RetT] = Connect[ParamT, RetT]
+type ExitT[**ParamT, RetT] = Exit[ParamT, RetT]
+type EnterT[**ParamT, RetT] = Enter[ParamT, RetT]
+type ComposedT[**ParamT, RetT] = Composed[ParamT, RetT]
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Db[**ParamT, RetT](composer_.Composer[ParamT, RetT], abc.ABC):
+    type Version = str
+
+    deserialize: typing.Callable[[str], RetT] = ast.literal_eval
+    path: pathlib.Path = pathlib.Path.home() / '.cache' / 'stranded' / 'sqlite3' / 'db'
+    serialize: typing.Callable[[RetT], str] = repr
+    version: Version = '0.0.0'
+
+    Composee: typing.ClassVar[type[Composee[typing.Any, typing.Any]]]
+    Connect: typing.ClassVar[type[Connect[typing.Any, typing.Any]]]
+    Exit: typing.ClassVar[type[Exit[typing.Any, typing.Any]]]
+    Enter: typing.ClassVar[type[Enter[typing.Any, typing.Any]]]
+    Composed: typing.ClassVar[type[Composed[typing.Any, typing.Any]]]
+
+    def __call__(self, composee: ComposeeT[ParamT, RetT], /) -> ComposedT[ParamT, RetT]:
+        table_name = f'{composee.__module__}.{composee.__qualname__}.{self.version}'
+        (connection := sqlite3.connect(self.path, check_same_thread=False, isolation_level=None)).execute(
+            f'CREATE TABLE IF NOT EXISTS `{table_name}` '  # noqa
+            f'(key TEXT PRIMARY KEY NOT NULL UNIQUE, ret TEXT NOT NULL)',  # noqa
+        )
+
+        return self.Composed(  # type: ignore[return-value]
+            __doc__=str(composee.__doc__),
+            __module__=str(composee.__module__),
+            __name__=str(composee.__name__),
+            __qualname__=str(composee.__qualname__),
+            __signature__=inspect.signature(composee),
+            composer=self,
+            stack=(
+                self.Enter(  # type: ignore[call-arg]
+                    composer=self,
+                    composee=composee,
+                    connection=connection,
+                    instance=None,
+                    table_name=table_name,
+                ),
+            ),
+        )
+
+
+Composer = Db

stranded/sqlite3/asyncio/__init__.py

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

stranded/sqlite3/asyncio/db_.py

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

stranded/sqlite3/db_.py

@@ -0,0 +1,13 @@
+import dataclasses
+import typing
+
+from .. import composer_
+from .abc import db_
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Db(composer_.Composer[..., typing.Any], db_.Db[..., typing.Any]): ...  # type: ignore[misc]
+
+
+Composer = Db
+db = Db()

stranded/sqlite3/threading/__init__.py

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

stranded/sqlite3/threading/db_.py

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

stranded/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 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/threading/composer_.py

@@ -0,0 +1,74 @@
+import abc
+import dataclasses
+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):
+    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):
+    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):
+    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):
+    def __call__(self, value: ValueT[ParamT, RetT], /) -> StackT: return super().__call__(value)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Composed[**ParamT, RetT](composer_.Composed[ParamT, RetT], abc.ABC):
+    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 += get_stack_(value)
+                case Composed() as composed_ if isinstance(value, Param): stack += composed_.stack
+                case composee_ if isinstance(value, Param):
+                    try:
+                        value = Return(ret=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