gendalf 0.1.0__tar.gz

gendalf-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Danil Troshnev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gendalf-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.3
+Name: gendalf
+Version: 0.1.0
+Summary: You shall pass... your domain to transport! A Python codegen tool for transport layers in DDD, supporting most popular transport / API frameworks.
+License: MIT
+Keywords: python,codegen
+Author: zerlok
+Author-email: danil.troshnev@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Dist: astlab (>=0.2.0,<0.3.0)
+Requires-Dist: click (>=8.1.8,<9.0.0)
+Project-URL: Homepage, https://github.com/zerlok/gendalf
+Project-URL: Issues, https://github.com/zerlok/gendalf/issues
+Description-Content-Type: text/markdown
+
+# Gendalf
+
+[![Latest Version](https://img.shields.io/pypi/v/gendalf.svg)](https://pypi.python.org/pypi/gendalf)
+[![Python Supported Versions](https://img.shields.io/pypi/pyversions/gendalf.svg)](https://pypi.python.org/pypi/gendalf)
+[![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
+[![Test Coverage](https://codecov.io/gh/zerlok/gendalf/branch/main/graph/badge.svg)](https://codecov.io/gh/zerlok/gendalf)
+[![Downloads](https://img.shields.io/pypi/dm/gendalf.svg)](https://pypistats.org/packages/gendalf)
+[![GitHub stars](https://img.shields.io/github/stars/zerlok/gendalf)](https://github.com/zerlok/gendalf/stargazers)
+
+*You shall pass... your domain to transport!*
+
+**Gendalf** is a Python code generation tool that simplifies the creation of **transport layer** code based on
+**Domain-Driven Design (DDD)** principles. With **gendalf**, you can effortlessly generate FastAPI, HTTPX, gRPC,
+aiohttp, and other transport framework code from your domain layer, ensuring that your business logic remains untouched
+while automating the generation of transport-related code.
+
+## Key Features
+
+- **Domain-Driven Design (DDD) approach**: Keeps your business logic in the domain layer and generates the transport
+  layer automatically.
+- **Multi-transport framework support**: Supports FastAPI and HTTPX (next in line: gRPC; and more frameworks planned for
+  future versions).
+- **Powered by [astlab](https://github.com/zerlok/astlab) generator**: Uses Python's built-in Abstract Syntax Tree (AST)
+  to generate Python modules from your domain entities and interfaces.
+
+## Why gendalf?
+
+With **gendalf**, you don’t have to worry about manually wiring your domain logic to transport code. Whether you're
+building APIs, microservices, or handling complex asynchronous communication, **gendalf** automates the transport layer
+creation: handles repetitive and error-prone process of writing endpoint handlers and clients from scratch, letting you
+focus on what matters most: your business logic.
+
+### Target Audience
+
+This tool is designed for Python developers working on services that follow the Domain-Driven Design (DDD) approach.
+It's particularly useful for:
+
+* Teams focusing on business logic without needing to handle the intricacies of APIs or transport layers.
+* Developers building Python API services.
+* Those looking for a way to streamline the development of API endpoints and client calls without the overhead of
+  boilerplate code.
+
+### Comparison with existing codegen solutions
+
+There are many tools for code generation in the Python ecosystem, but most are focused on simplifying specific tasks
+like serialization, or generating CRUD / REST operations. Here’s how **gendalf** project differs:
+
+* **Domain-Driven Design (DDD) Focus:** Unlike other code generation tools that focus on CRUD or specific transport
+  protocols, this project fully integrates with a DDD approach. This means developers work on the domain layer and let
+  the tool handle the presentation layer (API endpoints and clients).
+* **Fully Automated Code Generation:** The generated code for the server and client is complete and doesn’t require
+  further modifications, saving time and reducing boilerplate.
+* **Cross-Transport Flexibility:** Currently, it supports FastAPI and HTTPX, but future versions will add gRPC support,
+  allowing developers to generate code for various transport mechanisms without changing their domain logic.
+
+E.g. `grpcio-tools` requires `.proto` files specification first and generates client stubs & server interface, so on the
+server side an additional code is required: implement request deserialization from protobuf python classes to domain
+(value objects), invoke domain layer and then serialize protobuf response.
+
+## Transports & frameworks
+
+### FastAPI & HTTPX
+
+Run with `gendalf gen src fastapi`. It supports:
+
+- request-response (POST method, request & response in HTTP body in JSON format)
+- duplex streaming (WebSocket, requests & responses are in WS frames in JSON format)
+
+#### What’s Generated
+
+* **api/models.py**: Pydantic models for requests and responses that mirror the domain objects.
+* **api/client.py**: Client classes with async methods, ready to make API calls with appropriate typings for request and
+  response data.
+* **api/server.py**: Server handler classes, which include data serialization and domain logic invocation.
+
+The generated code is complete, with no need for additional modifications.
+
+#### Examples
+
+- [my greeter service](examples/my_greeter)
+
+### gRPC (not supported yet)
+
+**This framework support is not supported yet.**
+
+- unary-unary
+- stream-stream
+- unary-stream
+- stream-unary
+

gendalf-0.1.0/README.md

@@ -0,0 +1,89 @@
+# Gendalf
+
+[![Latest Version](https://img.shields.io/pypi/v/gendalf.svg)](https://pypi.python.org/pypi/gendalf)
+[![Python Supported Versions](https://img.shields.io/pypi/pyversions/gendalf.svg)](https://pypi.python.org/pypi/gendalf)
+[![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
+[![Test Coverage](https://codecov.io/gh/zerlok/gendalf/branch/main/graph/badge.svg)](https://codecov.io/gh/zerlok/gendalf)
+[![Downloads](https://img.shields.io/pypi/dm/gendalf.svg)](https://pypistats.org/packages/gendalf)
+[![GitHub stars](https://img.shields.io/github/stars/zerlok/gendalf)](https://github.com/zerlok/gendalf/stargazers)
+
+*You shall pass... your domain to transport!*
+
+**Gendalf** is a Python code generation tool that simplifies the creation of **transport layer** code based on
+**Domain-Driven Design (DDD)** principles. With **gendalf**, you can effortlessly generate FastAPI, HTTPX, gRPC,
+aiohttp, and other transport framework code from your domain layer, ensuring that your business logic remains untouched
+while automating the generation of transport-related code.
+
+## Key Features
+
+- **Domain-Driven Design (DDD) approach**: Keeps your business logic in the domain layer and generates the transport
+  layer automatically.
+- **Multi-transport framework support**: Supports FastAPI and HTTPX (next in line: gRPC; and more frameworks planned for
+  future versions).
+- **Powered by [astlab](https://github.com/zerlok/astlab) generator**: Uses Python's built-in Abstract Syntax Tree (AST)
+  to generate Python modules from your domain entities and interfaces.
+
+## Why gendalf?
+
+With **gendalf**, you don’t have to worry about manually wiring your domain logic to transport code. Whether you're
+building APIs, microservices, or handling complex asynchronous communication, **gendalf** automates the transport layer
+creation: handles repetitive and error-prone process of writing endpoint handlers and clients from scratch, letting you
+focus on what matters most: your business logic.
+
+### Target Audience
+
+This tool is designed for Python developers working on services that follow the Domain-Driven Design (DDD) approach.
+It's particularly useful for:
+
+* Teams focusing on business logic without needing to handle the intricacies of APIs or transport layers.
+* Developers building Python API services.
+* Those looking for a way to streamline the development of API endpoints and client calls without the overhead of
+  boilerplate code.
+
+### Comparison with existing codegen solutions
+
+There are many tools for code generation in the Python ecosystem, but most are focused on simplifying specific tasks
+like serialization, or generating CRUD / REST operations. Here’s how **gendalf** project differs:
+
+* **Domain-Driven Design (DDD) Focus:** Unlike other code generation tools that focus on CRUD or specific transport
+  protocols, this project fully integrates with a DDD approach. This means developers work on the domain layer and let
+  the tool handle the presentation layer (API endpoints and clients).
+* **Fully Automated Code Generation:** The generated code for the server and client is complete and doesn’t require
+  further modifications, saving time and reducing boilerplate.
+* **Cross-Transport Flexibility:** Currently, it supports FastAPI and HTTPX, but future versions will add gRPC support,
+  allowing developers to generate code for various transport mechanisms without changing their domain logic.
+
+E.g. `grpcio-tools` requires `.proto` files specification first and generates client stubs & server interface, so on the
+server side an additional code is required: implement request deserialization from protobuf python classes to domain
+(value objects), invoke domain layer and then serialize protobuf response.
+
+## Transports & frameworks
+
+### FastAPI & HTTPX
+
+Run with `gendalf gen src fastapi`. It supports:
+
+- request-response (POST method, request & response in HTTP body in JSON format)
+- duplex streaming (WebSocket, requests & responses are in WS frames in JSON format)
+
+#### What’s Generated
+
+* **api/models.py**: Pydantic models for requests and responses that mirror the domain objects.
+* **api/client.py**: Client classes with async methods, ready to make API calls with appropriate typings for request and
+  response data.
+* **api/server.py**: Server handler classes, which include data serialization and domain logic invocation.
+
+The generated code is complete, with no need for additional modifications.
+
+#### Examples
+
+- [my greeter service](examples/my_greeter)
+
+### gRPC (not supported yet)
+
+**This framework support is not supported yet.**
+
+- unary-unary
+- stream-stream
+- unary-stream
+- stream-unary

gendalf-0.1.0/pyproject.toml

@@ -0,0 +1,160 @@
+[tool.poetry]
+name = "gendalf"
+version = "0.1.0"
+description = "You shall pass... your domain to transport! A Python codegen tool for transport layers in DDD, supporting most popular transport / API frameworks."
+authors = ["zerlok <danil.troshnev@gmail.com>"]
+readme = "README.md"
+license = "MIT"
+keywords = [
+    "python",
+    "codegen",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Code Generators",
+    "Typing :: Typed",
+]
+
+[tool.poetry.urls]
+Homepage = "https://github.com/zerlok/gendalf"
+Issues = "https://github.com/zerlok/gendalf/issues"
+
+[tool.poetry.scripts]
+gendalf = "gendalf.cli:cli"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+click = "^8.1.8"
+astlab = "^0.2.0"
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.13.0"
+pytest = "^8.3.3"
+pytest-cov = "^6.0.0"
+ruff = ">=0.7.4,<0.9.0"
+
+[tool.poetry.group.examples.dependencies]
+httpx = "^0.28.1"
+uvicorn = "^0.34.0"
+fastapi = "^0.115.7"
+httpx-ws = "^0.7.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.ruff]
+target-version = "py39"
+include = ["src/**/*.py", "tests/**/*.py"]
+force-exclude = true
+line-length = 120
+output-format = "pylint"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "ANN", # because we use mypy
+    "D", # TODO: add docstrings to public code
+    "FA", # TODO: consider should we use __annotations__
+    "TD", # no task tracking
+    "FIX", # TODO: consider enable it against new code on pull requests
+    "COM812", # because ruff format suggests to skip it
+    "ISC001", # because ruff format suggests to skip it
+    "RET505", # clashes with mypy exhaustiveness check
+    "S101", # allow asserts for tests checks and mypy help
+    # TODO: stop ignore this rule
+    "UP007", # because of 3.9 support
+    # TODO: stop ignore this rule
+    "SIM117", # because ast builder 2.0 uses with statement to build contextual scope statemetns
+    "ARG002", # because `ruff` can't handle `override` from internal `gendalf._typing`.
+]
+
+[tool.ruff.lint.per-file-ignores]
+# CLI is built with `click` framework
+"src/gendalf/cli.py" = [
+    "FBT001", # CLI commands can use non keyword flag options
+    "PLR0913", # CLI commands can use a lots of arguments and options
+]
+"tests/**" = [
+    "PLR0913", # test functions can use a lots of arguments and fixtures
+]
+
+
+[tool.mypy]
+files = ["src", "tests"]
+strict = true
+disallow_any_unimported = true
+disallow_any_expr = true
+disallow_any_decorated = true
+disallow_any_explicit = true
+disallow_any_generics = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_decorators = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_return_any = true
+warn_unreachable = true
+strict_equality = true
+strict_optional = true
+enable_error_code = [
+    "redundant-self",
+    "redundant-expr",
+    "possibly-undefined",
+    "truthy-bool",
+    "truthy-iterable",
+    "ignore-without-code",
+    "unused-awaitable",
+    "explicit-override",
+    "mutable-override",
+    "unimported-reveal",
+    "narrowed-type-not-subtype",
+]
+
+# NOTE: in some modules it's hard to disallow `typing.Any` completely, so allow it (e.g. `click` has `typing.Any` in
+# some decorators).
+[[tool.mypy.overrides]]
+module = [
+    "gendalf.cli",
+    "gendalf.entrypoint.inspection",
+    "gendalf.generator.model.type_inspection.visitor.trait",
+]
+disallow_any_expr = false
+
+# NOTE: allow return `typing.Any` in test fixtures (e.g. mock objects created with `create_autospec`)
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disallow_any_expr = false
+disallow_any_explicit = false
+warn_return_any = false
+
+
+[tool.pytest.ini_options]
+pythonpath = [
+    "src",
+]
+addopts = [
+    "--cov=src",
+    "--cov-report=term-missing",
+]
+testpaths = [
+    "tests",
+]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "@abc.abstractmethod",
+    "if __name__ == .__main__.:",
+    "if t.TYPE_CHECKING:",
+]
+show_missing = true

gendalf-0.1.0/src/gendalf/_typing.py

@@ -0,0 +1,24 @@
+__all__ = [
+    "Self",
+    "TypeAlias",
+    "TypeGuard",
+    "assert_never",
+    "override",
+]
+
+import typing as t
+
+# NOTE: this allows to use methods with `Self` during runtime (when typing_extensions is not installed).
+if t.TYPE_CHECKING:
+    from typing_extensions import Self, TypeAlias, TypeGuard, assert_never, override
+
+else:
+    Self = t.Any
+    TypeAlias = t.Any
+    TypeGuard = t.Optional
+
+    def assert_never(*args: object, **kwargs: object) -> t.NoReturn:
+        raise RuntimeError(args, kwargs)  # pragma: no cover
+
+    def override(func: object) -> object:
+        return func

gendalf-0.1.0/src/gendalf/cli.py

@@ -0,0 +1,123 @@
+import typing as t
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+
+from gendalf._typing import assert_never
+from gendalf.entrypoint.inspection import inspect_source_dir
+from gendalf.entrypoint.printer import Printer
+from gendalf.generator.fastapi import FastAPICodeGenerator
+from gendalf.model import GeneratorContext
+
+
+@dataclass(frozen=True)
+class CLIContext:
+    source: Path
+    ignore_module_on_import_error: bool
+
+
+pass_cli_context = click.make_pass_decorator(CLIContext)
+
+
+@click.group()
+@click.pass_context
+@click.argument(
+    "source",
+    type=click.Path(exists=True, resolve_path=True, path_type=Path),
+)
+@click.option(
+    "--ignore-module-on-import-error",
+    type=bool,
+    is_flag=True,
+    default=False,
+)
+def cli(
+    context: click.Context,
+    source: Path,
+    ignore_module_on_import_error: bool,
+) -> None:
+    context.obj = CLIContext(
+        source=source,
+        ignore_module_on_import_error=ignore_module_on_import_error,
+    )
+
+
+OPT_OUTPUT = click.option(
+    "-o",
+    "--output",
+    type=click.Path(writable=True, resolve_path=True, path_type=Path),
+    default=None,
+)
+
+
+GenKind = t.Literal["fastapi"]
+
+
+@cli.command()
+@click.pass_obj
+@click.argument(
+    "kind",
+    type=click.Choice(t.get_args(GenKind)),
+)
+@OPT_OUTPUT
+@click.option(
+    "-p",
+    "--package",
+    type=str,
+    default=None,
+)
+@click.option(
+    "--dry-run",
+    type=bool,
+    is_flag=True,
+    default=False,
+)
+def cast(
+    context: CLIContext,
+    kind: GenKind,
+    output: t.Optional[Path],
+    package: t.Optional[str],
+    dry_run: bool,
+) -> None:
+    """Generate code for specified python package."""
+
+    gen_context = GeneratorContext(
+        entrypoints=list(
+            inspect_source_dir(context.source, ignore_module_on_import_error=context.ignore_module_on_import_error)
+        ),
+        source=context.source,
+        output=output if output is not None else context.source,
+        package=package,
+    )
+
+    if kind == "fastapi":
+        gen = FastAPICodeGenerator()
+    else:
+        assert_never(kind)
+
+    for file in gen.generate(gen_context).files:
+        if dry_run:
+            continue
+
+        file.path.parent.mkdir(parents=True, exist_ok=True)
+        with file.path.open("w") as fd:
+            fd.write(file.content)
+
+
+@cli.command()
+@click.pass_obj
+def show(context: CLIContext) -> None:
+    """Show info about the package"""
+
+    printer = Printer(click.echo)
+
+    for entrypoint in inspect_source_dir(
+        context.source,
+        ignore_module_on_import_error=context.ignore_module_on_import_error,
+    ):
+        entrypoint.accept(printer)
+
+
+if __name__ == "__main__":
+    cli()

gendalf-0.1.0/src/gendalf/entrypoint/decorator.py

@@ -0,0 +1,38 @@
+import typing as t
+from functools import partial
+
+from gendalf.model import EntrypointOptions
+
+T = t.TypeVar("T")
+__ENTRYPOINT_CONFIG = """__gendalf_entrypoint_config__"""
+
+
+@t.overload
+def entrypoint(obj: type[T]) -> type[T]: ...
+
+
+@t.overload
+def entrypoint(*, name: str) -> t.Callable[[type[T]], type[T]]: ...
+
+
+def entrypoint(
+    obj: t.Optional[type[T]] = None,
+    name: t.Optional[str] = None,
+) -> t.Union[type[T], t.Callable[[type[T]], type[T]]]:
+    return (
+        _mark_entrypoint(obj, EntrypointOptions())
+        if obj is not None
+        # NOTE: mypy thinks that `T` of `_mark_entrypoint` is not the same `T` of `entrypoint`
+        else t.cast(t.Callable[[type[T]], type[T]], partial(_mark_entrypoint, options=EntrypointOptions(name=name)))
+    )
+
+
+def _mark_entrypoint(obj: type[T], options: EntrypointOptions) -> type[T]:
+    setattr(obj, __ENTRYPOINT_CONFIG, options)
+    return obj
+
+
+def get_entrypoint_options(obj: object) -> t.Optional[EntrypointOptions]:
+    opts: object = getattr(obj, __ENTRYPOINT_CONFIG, None)
+    assert opts is None or isinstance(opts, EntrypointOptions)
+    return opts

gendalf-0.1.0/src/gendalf/entrypoint/inspection.py

@@ -0,0 +1,112 @@
+import abc
+import importlib
+import inspect
+import sys
+import typing as t
+from pathlib import Path
+from types import ModuleType
+
+from astlab.info import TypeInfo
+from astlab.reader import import_module, walk_package_modules
+
+from gendalf.entrypoint.decorator import get_entrypoint_options
+from gendalf.model import EntrypointInfo, MethodInfo, ParameterInfo, StreamStreamMethodInfo, UnaryUnaryMethodInfo
+from gendalf.option import Option
+
+
+def inspect_source_dir(
+    src: Path,
+    *,
+    ignore_module_on_import_error: bool = False,
+) -> t.Iterable[EntrypointInfo]:
+    sys.path.append(str(src))
+    try:
+        for path in walk_package_modules(src):
+            if path.stem.startswith("_"):
+                continue
+
+            try:
+                module = import_module(path)
+
+            except ImportError:
+                if not ignore_module_on_import_error:
+                    raise
+
+            else:
+                yield from inspect_module(module)
+
+    finally:
+        importlib.invalidate_caches()
+        sys.path.remove(str(src))
+
+
+def inspect_module(module: ModuleType) -> t.Iterable[EntrypointInfo]:
+    for name, obj in inspect.getmembers(module):
+        if not inspect.isclass(obj) or obj.__module__ != module.__name__:
+            continue
+
+        opts = get_entrypoint_options(obj)
+        if opts is None:
+            continue
+
+        type_info = TypeInfo.from_type(obj)
+
+        yield EntrypointInfo(
+            name=opts.name if opts.name is not None else name,
+            type_=type_info,
+            methods=tuple(
+                inspect_method(member_name, member)
+                for member_name, member in inspect.getmembers(obj)
+                if not member_name.startswith("_") and callable(member)
+            ),
+            doc=inspect.getdoc(obj),
+        )
+
+
+class Func(t.Protocol):
+    @abc.abstractmethod
+    def __call__(self, *args: object, **kwargs: object) -> object:
+        raise NotImplementedError
+
+
+def inspect_method(name: str, func: Func) -> MethodInfo:
+    signature = inspect.signature(func)
+
+    params = list(signature.parameters.values())[1:]
+
+    # TODO: uncomment
+    if len(params) == 1 and (streaming_type := extract_streaming_type(params[0].annotation)) is not None:
+        return StreamStreamMethodInfo(
+            name=name,
+            input_=_build_param(params[0].replace(annotation=streaming_type)),
+            output=extract_streaming_type(signature.return_annotation),
+            doc=inspect.getdoc(func),
+        )
+
+    return UnaryUnaryMethodInfo(
+        name=name,
+        # skip `self`
+        params=[_build_param(param) for param in params],
+        returns=signature.return_annotation,
+        doc=inspect.getdoc(func),
+    )
+
+
+def extract_streaming_type(obj: object) -> t.Optional[type[object]]:
+    origin = t.get_origin(obj)
+    if not isinstance(origin, type) or not issubclass(origin, (t.Iterator, t.AsyncIterator)):
+        return None
+
+    args = t.get_args(obj)
+    assert len(args) == 1
+
+    # TODO: remove cast, check types
+    return t.cast(type[object], args[0])
+
+
+def _build_param(param: inspect.Parameter) -> ParameterInfo:
+    return ParameterInfo(
+        name=param.name,
+        annotation=param.annotation,
+        default=Option(param.default) if param.default is not param.empty else Option[object].empty(),
+    )