seampact-ninja 1.0.0__tar.gz

seampact_ninja-1.0.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+dist/

seampact_ninja-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julien Metral
+
+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.

seampact_ninja-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.5
+Name: seampact-ninja
+Version: 1.0.0
+Summary: The Django Ninja target of seampact: its generator and the placement runtime of the generated code.
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: django-ninja>=1.5.3
+Requires-Dist: seampact-codegen[pydantic]==1.0.0
+Requires-Dist: seampact-django==1.0.0
+Requires-Dist: seampact-hooks==1.0.0
+Provides-Extra: generate
+Requires-Dist: seampact-django[generate]==1.0.0; extra == 'generate'
+Description-Content-Type: text/markdown
+
+The seampact Django Ninja target: the `seampact-ninja` generator, found through the `seampact.generators` entry point, and the Ninja runtime of the code it generates.

seampact_ninja-1.0.0/README.md

@@ -0,0 +1 @@
+The seampact Django Ninja target: the `seampact-ninja` generator, found through the `seampact.generators` entry point, and the Ninja runtime of the code it generates.

seampact_ninja-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling==1.33.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "seampact-ninja"
+version = "1.0.0"
+description = "The Django Ninja target of seampact: its generator and the placement runtime of the generated code."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+# The matrix holds major.minor and its Ninja floor is 1.5; 1.5.3 is the first release whose metadata declares Django
+# 6.0, so an older 1.5 would not install beside Django 6. Pydantic comes through Ninja's own range.
+dependencies = [
+    "django-ninja>=1.5.3",
+    "seampact-codegen[pydantic]==1.0.0",
+    "seampact-django==1.0.0",
+    "seampact-hooks==1.0.0",
+]
+classifiers = [
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Framework :: Django :: 6.1",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+# What the generator needs; a production install of an app leaves it out.
+generate = ["seampact-django[generate]==1.0.0"]
+
+[project.entry-points."seampact.generators"]
+ninja = "seampact.ninja.generator:NinjaGenerator"
+
+# PEP 420: `seampact` is a namespace shared by every seampact distribution, so it has no `__init__.py`.
+[tool.hatch.build.targets.wheel]
+packages = ["src/seampact"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/seampact", "LICENSE"]
+
+[tool.uv.sources]
+seampact-codegen = { workspace = true }
+seampact-django = { workspace = true }
+seampact-hooks = { workspace = true }

seampact_ninja-1.0.0/src/seampact/ninja/__init__.py

@@ -0,0 +1 @@
+"""The Django Ninja target of seampact: the `seampact-ninja` generator and the runtime of the code it generates."""

seampact_ninja-1.0.0/src/seampact/ninja/generator.py

@@ -0,0 +1,104 @@
+"""The `seampact-ninja` generator (ADR 0027 "Ninja"), the class the `seampact.generators` entry point names. Per api it
+writes one package: `schemas.py` (the schema models and each operation's input parts, through the shared Pydantic
+emitter), `operations.py` (the operation types and endpoints protocols), `contract.py` (the contract the runtime
+reads), `routes.py` (the route names and URL builders, unless `routeHelpers: false`), `django.py` (the boundary
+middleware's declaration), `ninja.py` (the placement and `bind_<api>()`) and, with `nativeDocs`, `native_docs.json`
+(seampact's operation objects for Ninja's document). Every refusal is listed at once, and no
+file is written when there is one."""
+
+from collections.abc import Sequence
+from typing import Final
+
+from seampact.codegen.contract_module import contract_module
+from seampact.codegen.handler_forms import handler_warnings
+from seampact.codegen.input_schemas import proof_models, with_input_schemas
+from seampact.codegen.kept_forms import refuse_kept_forms
+from seampact.codegen.matrix_row import refuse_missing_matrix_row
+from seampact.codegen.names import api_names
+from seampact.codegen.native_docs_file import FrameworkDocument, native_docs_file
+from seampact.codegen.operation_types import operation_types_module
+from seampact.codegen.printer import PythonModule
+from seampact.codegen.pydantic_forms import refuse_unserved_forms
+from seampact.codegen.pydantic_layout import api_layout
+from seampact.codegen.pydantic_models import PYDANTIC_MAJOR, PYDANTIC_PACKAGE, pydantic_schemas_module
+from seampact.codegen.refusals import Refusals
+from seampact.codegen.route_helpers import route_helpers_module
+from seampact.codegen.routes import route_table
+from seampact.codegen.runtime.version import RUNTIME_VERSION
+from seampact.django.emitters import BoundaryBase, boundary_module, contract_paths, routes_named_by_path
+from seampact.ir.config.problem import ConfigProblem
+from seampact.ir.model import ContractIR
+from seampact.ir.naming import IrName, NamingRole, python_identifier
+from seampact.ir.read import IrSupport
+from seampact.ir.run.generator import TargetEntry
+from seampact.ir.write import GeneratedFile
+from seampact.ninja.options import ninja_options
+from seampact.ninja.placement_module import placement_module
+
+TARGET: Final = "ninja"
+DISTRIBUTION: Final = "seampact-ninja"
+_HTTP_OPERATION: Final = "httpOperation"
+_NINJA_DOCUMENT: Final = FrameworkDocument(TARGET, "Django Ninja")
+_NAMES_REGISTERED: Final = (
+    'The route name of each operation, under the NinjaAPI\'s urls_namespace: reverse "<namespace>:<name>".'
+)
+_BOUNDARY_BASE: Final = BoundaryBase("seampact.ninja.runtime", "_ninja_runtime", "NinjaContractBoundary")
+
+
+class NinjaGenerator:
+    def ir_support(self) -> IrSupport:
+        return IrSupport.of_model(kinds=[_HTTP_OPERATION])
+
+    def framework_docs_off_fix(self) -> str | None:
+        return (
+            "Remove `frameworkDocs: off` from the entry and switch Ninja's own docs off in the app: "
+            "`NinjaAPI(docs_url=None, openapi_url=None)`."
+        )
+
+    def handler_warnings(self, ir: ContractIR, entry: TargetEntry) -> Sequence[ConfigProblem]:
+        return handler_warnings(ir, entry.id, entry.api)
+
+    def generate(self, ir: ContractIR, entry: TargetEntry) -> Sequence[GeneratedFile]:
+        refusals = Refusals(entry.id, TARGET, DISTRIBUTION)
+        options = ninja_options(TARGET, entry.options, entry.artefacts, refusals)
+        mount = entry.mount or ""
+
+        refuse_kept_forms(ir, refusals)
+        refuse_missing_matrix_row(entry, refusals, "Django and Django Ninja")
+        refuse_unserved_forms(ir, refusals)
+        error_codes = sorted({error.code for operation in ir.operations for error in operation.errors})
+        layout = api_layout(ir, error_codes, refusals)
+        with_inputs = with_input_schemas(ir, layout)
+        names = api_names(with_inputs, refusals)
+        paths = contract_paths(route_table(ir, mount, refusals), [operation.id for operation in ir.operations])
+        routes = routes_named_by_path(paths)
+        api_class = python_identifier(IrName(tuple(ir.api.name.segments), NamingRole.SCHEMA))
+        files = {
+            "__init__.py": PythonModule(f"The generated code of api '{ir.api.id}' for the Ninja target.").text(),
+            "schemas.py": pydantic_schemas_module(with_inputs, names, options.rules, refusals),
+            "operations.py": operation_types_module(with_inputs, names, layout, refusals),
+            "contract.py": contract_module(ir, names, mount, refusals),
+            "django.py": boundary_module(
+                ir.api.id,
+                api_class,
+                RUNTIME_VERSION,
+                {},
+                options.shared.run_time_options(),
+                entry,
+                base=_BOUNDARY_BASE,
+                settings_module=None,
+                model_framework=(PYDANTIC_PACKAGE, PYDANTIC_MAJOR),
+            ),
+            "ninja.py": placement_module(ir, layout, proof_models(layout, names), routes, mount, options),
+        }
+
+        if options.shared.route_helpers:
+            files["routes.py"] = route_helpers_module(ir, routes, refusals, _NAMES_REGISTERED)
+
+        if options.native_docs:
+            native_docs = native_docs_file(entry.native_docs, layout.operations, _NINJA_DOCUMENT, refusals)
+            files.update({} if native_docs is None else {native_docs.path: native_docs.contents})
+
+        refusals.raise_if_any()
+
+        return [GeneratedFile(path, contents) for path, contents in sorted(files.items())]

seampact_ninja-1.0.0/src/seampact/ninja/options.py

@@ -0,0 +1,40 @@
+"""The options and artefact switches of a ninja entry (ADR 0027 "Options and registration"): the Django targets'
+shared set, `rules` for the shared Pydantic models, `views`, `sync` (the default) or `async`, and the `nativeDocs`
+artefact switch."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Final
+
+from seampact.codegen.pydantic_models import RulesMode
+from seampact.codegen.refusals import Refusals
+from seampact.django.emitters import DjangoTargetOptions, OptionReader, django_target_options
+from seampact.ir.config.json_value import JsonValue
+from seampact.ninja.views_mode import ViewsMode
+
+_RULES: Final = "rules"
+_VIEWS: Final = "views"
+_NATIVE_DOCS: Final = "nativeDocs"
+
+
+@dataclass(frozen=True, slots=True)
+class NinjaOptions:
+    shared: DjangoTargetOptions
+    rules: RulesMode
+    views: ViewsMode
+    native_docs: bool
+
+
+def ninja_options(
+    target: str, options: Mapping[str, JsonValue], artefacts: Mapping[str, JsonValue], refusals: Refusals
+) -> NinjaOptions:
+    own_options = (_RULES, _VIEWS)
+    shared = django_target_options(target, own_options, options, artefacts, refusals, own_artefacts=(_NATIVE_DOCS,))
+    reader = OptionReader(options, refusals)
+
+    return NinjaOptions(
+        shared,
+        reader.choice(_RULES, RulesMode.NATIVE),
+        reader.choice(_VIEWS, ViewsMode.SYNC),
+        native_docs=artefacts.get(_NATIVE_DOCS) is True,
+    )

seampact_ninja-1.0.0/src/seampact/ninja/placement_module.py

@@ -0,0 +1,267 @@
+"""The `ninja` module of an api's package (ADR 0027 "Ninja"): `GENERATED_BY`, the api's placement (each contract
+operation's route below the router's prefix, `GET` with `HEAD`, under the URL name of its path; its contract exception
+base; how its views run; its credentials types), the `<Api>HandlerFactories` the app fills, one function per
+operation calling its handler method, one view per operation taking the request and one `str` per path placeholder,
+and `bind_<api>()`, which hands each operation to the runtime with its view. The views are plain functions under
+`views: sync` and `async def` under `views: async`."""
+
+from collections.abc import Mapping, Sequence
+from typing import Final
+
+from seampact.codegen.native_docs_file import NATIVE_DOCS_FILE
+from seampact.codegen.placement_lines import (
+    add_operation_call,
+    credentials_types,
+    operation_types_arguments,
+    tuple_literal,
+    unexpected_error_listener,
+)
+from seampact.codegen.printer import INDENT, PythonModule, bracketed, string_literal
+from seampact.codegen.pydantic_layout import ApiLayout
+from seampact.codegen.routes import RouteEntry
+from seampact.codegen.runtime import RUNTIME_VERSION
+from seampact.codegen.source_lines import with_local_imports
+from seampact.django.emitters.urls_module import PATH_ARGUMENT_PREFIX
+from seampact.ir.model import ContractIR
+from seampact.ninja.options import NinjaOptions
+from seampact.ninja.views_mode import ViewsMode
+
+_RUNTIME: Final = "_runtime"
+_HOOKS: Final = "_hooks"
+_ABC: Final = "_abc"
+_HTTP: Final = "_http"
+_NINJA: Final = "_ninja"
+# Each operation's handler call and view: no module alias starts so, whatever the operation's name.
+_CALL_PREFIX: Final = "_call_"
+_VIEW_PREFIX: Final = "_view_"
+_CONTRACT_MODULE: Final = "contract"
+_SCHEMAS_MODULE: Final = "schemas"
+_BIND_DOC: Final = (
+    "Adds the api's Router to `api`; the URLconf prefix of `api.urls` plus `prefix` must equal the entry's mount."
+)
+
+
+def placement_module(
+    ir: ContractIR,
+    layout: ApiLayout,
+    proof_models: Mapping[str, str],
+    routes: Sequence[RouteEntry],
+    mount: str,
+    options: NinjaOptions,
+) -> str:
+    """`routes` are named by path, in registration order; `proof_models` names the `<Op>Proofs` class of each operation
+    whose body has proofs."""
+    module = PythonModule(f"The Django Ninja placement of api '{ir.api.id}'.")
+    module.imported("collections.abc", _ABC)
+    module.imported("dataclasses", "_dataclasses")
+    module.imported("typing", "_typing")
+
+    if options.native_docs:
+        module.imported("pathlib", "_pathlib")
+
+    module.imported("django.http", _HTTP)
+    module.imported("ninja", _NINJA)
+    module.imported("seampact.ninja.runtime", _RUNTIME)
+    module.imported("seampact.hooks", _HOOKS)
+    root_names = [layout.contract_error, *(credentials.class_name for credentials in layout.credentials.values())]
+    operations = [operation for operation in ir.operations if operation.id in layout.operations]
+
+    for operation in operations:
+        names = layout.operations[operation.id]
+        root_names += [names.endpoints, names.request, names.result, names.errors, *names.responses.values()]
+
+    head = [f"GENERATED_BY: _typing.Final = {string_literal(RUNTIME_VERSION)}"]
+    local_modules = [_CONTRACT_MODULE, _SCHEMAS_MODULE] if proof_models else [_CONTRACT_MODULE]
+    module.add_block(with_local_imports(local_modules, root_names, head))
+    module.add_block(_placement(ir, layout, routes, mount, options))
+    module.add_block(_handler_factories(layout))
+    module.add_block(unexpected_error_listener(ir.api.id, _HOOKS, layout))
+
+    for operation in operations:
+        module.add_block(_handler_call(layout, operation.id, options.views))
+
+    for route in routes:
+        module.add_block(_view(layout, route, options.views))
+
+    module.add_block(_bind(ir, layout, proof_models, routes))
+
+    return module.text()
+
+
+def router_path(route: RouteEntry, mount: str) -> str:
+    """The route's path below the router's prefix, which with the URLconf's prefix makes `mount`."""
+    mount_depth = len(mount.split("/")) - 1 if mount else 0
+
+    return "".join(
+        "/" + (segment.text if segment.attribute is None else f"{{{PATH_ARGUMENT_PREFIX}{segment.attribute}}}")
+        for segment in route.segments[mount_depth:]
+    )
+
+
+def _placement(
+    ir: ContractIR, layout: ApiLayout, routes: Sequence[RouteEntry], mount: str, options: NinjaOptions
+) -> list[str]:
+    route_lines: list[str] = []
+
+    for route in routes:
+        arguments = [
+            string_literal(route.operation_id),
+            string_literal(route.name),
+            string_literal(router_path(route, mount)),
+            tuple_literal(route.methods),
+        ]
+        route_lines += bracketed(INDENT * 2, f"{_RUNTIME}.OperationRoute", arguments, ",")
+
+    return [
+        f"PLACEMENT: _typing.Final = {_RUNTIME}.ApiPlacement(",
+        f"{INDENT}api={string_literal(ir.api.id)},",
+        f"{INDENT}generated_by=GENERATED_BY,",
+        f"{INDENT}mount={string_literal(mount)},",
+        f"{INDENT}routes=(",
+        *route_lines,
+        f"{INDENT}),",
+        f"{INDENT}error_base={layout.contract_error},",
+        f"{INDENT}views={_RUNTIME}.ViewsMode.{options.views.name},",
+        *credentials_types(_RUNTIME, layout),
+        *_native_docs(options),
+        ")",
+    ]
+
+
+def _native_docs(options: NinjaOptions) -> list[str]:
+    """With `nativeDocs`, seampact's operation objects for Ninja's document, read from the generated file."""
+    if not options.native_docs:
+        return []
+
+    native_docs_path = f"_pathlib.Path(__file__).with_name({string_literal(NATIVE_DOCS_FILE)})"
+
+    return [f"{INDENT}native_docs={_RUNTIME}.read_native_docs({native_docs_path}),"]
+
+
+def _handler_factories(layout: ApiLayout) -> list[str]:
+    lines = [
+        "@_dataclasses.dataclass(frozen=True, slots=True, kw_only=True)",
+        f"class {layout.handler_factories}:",
+        f'{INDENT}"""Builds each endpoints protocol\'s handlers from the HttpRequest; None fails the boot."""',
+        "",
+    ]
+    lines += [
+        f"{INDENT}{attribute}: {_RUNTIME}.Factory[{endpoints}] | None"
+        for endpoints, attribute in layout.endpoints_owners().items()
+    ]
+
+    return lines
+
+
+def _handler_call(layout: ApiLayout, operation_id: str, views: ViewsMode) -> list[str]:
+    """A sync call narrows the method's result itself: the checkers cannot infer the result union through a generic
+    helper."""
+    names = layout.operations[operation_id]
+    parameters = [f"endpoints: {names.endpoints}", f"request: {names.request}"]
+
+    if views is ViewsMode.ASYNC:
+        return [
+            *bracketed("", f"async def {_CALL_PREFIX}{names.method}", parameters, f" -> {names.result}:"),
+            f"{INDENT}return await {_RUNTIME}.call_handler_async(endpoints.{names.method}, request)",
+        ]
+
+    return [
+        *bracketed("", f"def {_CALL_PREFIX}{names.method}", parameters, f" -> {names.result}:"),
+        f"{INDENT}result = endpoints.{names.method}(request)",
+        "",
+        f"{INDENT}if isinstance(result, {_ABC}.Awaitable):",
+        f"{INDENT * 2}raise {_RUNTIME}.async_handler_error(endpoints.{names.method}, result)",
+        "",
+        f"{INDENT}return result",
+    ]
+
+
+def _view(layout: ApiLayout, route: RouteEntry, views: ViewsMode) -> list[str]:
+    """Ninja reads one `str` parameter per placeholder, which it cannot refuse; the view leaves them to the boundary's
+    raw decoding."""
+    names = layout.operations[route.operation_id]
+    parameters = [
+        f"request: {_HTTP}.HttpRequest",
+        *(f"{PATH_ARGUMENT_PREFIX}{segment.attribute}: str" for segment in route.segments if segment.attribute),
+    ]
+    operation = string_literal(route.operation_id)
+
+    if views is ViewsMode.ASYNC:
+        return [
+            *bracketed("", f"async def {_VIEW_PREFIX}{names.method}", parameters, f" -> {_HTTP}.HttpResponse:"),
+            f"{INDENT}return await {_RUNTIME}.serve_operation_async(request, PLACEMENT, {operation})",
+        ]
+
+    return [
+        *bracketed("", f"def {_VIEW_PREFIX}{names.method}", parameters, f" -> {_HTTP}.HttpResponse:"),
+        f"{INDENT}return {_RUNTIME}.serve_operation(request, PLACEMENT, {operation})",
+    ]
+
+
+def _bind(
+    ir: ContractIR, layout: ApiLayout, proof_models: Mapping[str, str], routes: Sequence[RouteEntry]
+) -> list[str]:
+    def factories(hook: str) -> str:
+        return f"{_ABC}.Mapping[str, {_RUNTIME}.Factory[{_HOOKS}.{hook}]] | None = None"
+
+    parameters = [
+        f"api: {_NINJA}.NinjaAPI",
+        "*",
+        "prefix: str",
+        f"handlers: {layout.handler_factories}",
+        f"authenticate: {factories('AuthenticateHook')}",
+        f"deciders: {factories('DecideHook')}",
+        f"scope_resolvers: {factories('ResolveScopeHook')}",
+        f"idempotency_store: {_RUNTIME}.Factory[{_HOOKS}.IdempotencyStore] | None = None",
+        f"on_unexpected_error: {_RUNTIME}.Factory[{layout.unexpected_error_listener}] | None = None",
+        f"access: {_ABC}.Mapping[str, {_RUNTIME}.AccessSettings] | None = None",
+        f"responses: {_RUNTIME}.ResponsesMode | None = None",
+        "body_validation: bool | None = None",
+        f"operations: {_ABC}.Mapping[str, {_RUNTIME}.OperationSettings] | None = None",
+        "public_origin: str | None = None",
+    ]
+    settings = [
+        "responses=responses",
+        "body_validation=body_validation",
+        "operations=operations or {}",
+        "public_origin=public_origin",
+    ]
+    lines = [
+        *bracketed("", f"def {layout.bind_function}", parameters, " -> None:"),
+        f'{INDENT}"""{_BIND_DOC}"""',
+        f"{INDENT}binding = {_RUNTIME}.api_binding(",
+        f"{INDENT * 2}PLACEMENT,",
+        f"{INDENT * 2}_{_CONTRACT_MODULE}.CONTRACT,",
+        f"{INDENT * 2}api,",
+        f"{INDENT * 2}prefix=prefix,",
+        f"{INDENT * 2}authenticate=authenticate or {{}},",
+        f"{INDENT * 2}deciders=deciders or {{}},",
+        f"{INDENT * 2}scope_resolvers=scope_resolvers or {{}},",
+        f"{INDENT * 2}idempotency_store=idempotency_store,",
+        f"{INDENT * 2}on_unexpected_error=on_unexpected_error,",
+        f"{INDENT * 2}access=access or {{}},",
+        *bracketed(INDENT * 2, f"settings={_RUNTIME}.RunSettings", settings, ","),
+        f"{INDENT})",
+        "",
+    ]
+
+    for route in routes:
+        lines += _add_operation(layout, route.operation_id, proof_models.get(route.operation_id))
+
+    return [*lines, "", f"{INDENT}{_RUNTIME}.bind_api(binding)"]
+
+
+def _add_operation(layout: ApiLayout, operation_id: str, proof_model: str | None) -> list[str]:
+    """One `add_operation` call, split as ruff splits it."""
+    names = layout.operations[operation_id]
+    proofs = None if proof_model is None else f"_{_SCHEMAS_MODULE}.{proof_model}"
+    types = operation_types_arguments(layout, operation_id, proofs)
+    arguments = [
+        "binding",
+        string_literal(operation_id),
+        f"{_VIEW_PREFIX}{names.method}",
+        f"handlers.{names.owner_attribute}",
+        f"{_CALL_PREFIX}{names.method}",
+    ]
+
+    return add_operation_call(_RUNTIME, arguments, types)

seampact_ninja-1.0.0/src/seampact/ninja/runtime/__init__.py

@@ -0,0 +1,44 @@
+"""The Ninja placement runtime the generated code imports (ADR 0027 "Ninja"): the declarations of one api's placement,
+its binding and Router, its boundary middleware, the body of its views and their handler calls. The
+framework-neutral steps come from `seampact.codegen.runtime` and the shared boundary from `seampact.django.runtime`."""
+
+from seampact.codegen.runtime.access_steps import CredentialsType
+from seampact.codegen.runtime.native_docs import NativeDocsError, read_native_docs
+from seampact.codegen.runtime.reply_verdict import ResponsesMode
+from seampact.codegen.runtime.run_settings import OperationSettings, OperationTypes, RunSettings
+from seampact.ninja.runtime.binding import ApiBinding, BindingError, add_operation, api_binding, bind_api
+from seampact.ninja.runtime.boundary import NinjaContractBoundary
+from seampact.ninja.runtime.placement import AccessSettings, ApiPlacement, Factory, NinjaAuth, OperationRoute
+from seampact.ninja.runtime.views import (
+    async_handler_error,
+    call_handler_async,
+    serve_operation,
+    serve_operation_async,
+)
+from seampact.ninja.views_mode import ViewsMode
+
+__all__ = [
+    "AccessSettings",
+    "ApiBinding",
+    "ApiPlacement",
+    "BindingError",
+    "CredentialsType",
+    "Factory",
+    "NativeDocsError",
+    "NinjaAuth",
+    "NinjaContractBoundary",
+    "OperationRoute",
+    "OperationSettings",
+    "OperationTypes",
+    "ResponsesMode",
+    "RunSettings",
+    "ViewsMode",
+    "add_operation",
+    "api_binding",
+    "async_handler_error",
+    "bind_api",
+    "call_handler_async",
+    "read_native_docs",
+    "serve_operation",
+    "serve_operation_async",
+]