domainkit 0.1.0__tar.gz

domainkit-0.1.0/LICENSE

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

domainkit-0.1.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: domainkit
+Version: 0.1.0
+Summary: A Django-style framework for domain-driven FastAPI services.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ddd,domain-driven-design,fastapi,sqlalchemy,outbox,framework
+Author: karim magdy
+Author-email: karimhady111@gmail.com
+Requires-Python: >=3.13,<4
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Provides-Extra: metrics
+Provides-Extra: postgres
+Provides-Extra: sqlite
+Provides-Extra: tracing
+Requires-Dist: aiosqlite (>=0.22.1,<0.23.0) ; extra == "sqlite"
+Requires-Dist: alembic (>=1.20.0,<2.0.0)
+Requires-Dist: asyncpg (>=0.31.0,<0.32.0) ; extra == "postgres"
+Requires-Dist: fastapi (>=0.141.1,<0.142.0)
+Requires-Dist: opentelemetry-api (>=1.45.1,<2.0.0) ; extra == "tracing"
+Requires-Dist: prometheus-client (>=0.26.0,<0.27.0) ; extra == "metrics"
+Requires-Dist: pydantic (>=2.14.1,<3.0.0)
+Requires-Dist: python-dotenv (>=1.2.4,<2.0.0)
+Requires-Dist: sqlalchemy[asyncio] (>=2.0.54,<2.1)
+Requires-Dist: uvicorn[standard] (>=0.54.0,<0.55.0)
+Project-URL: Changelog, https://github.com/karimmattar/domainkit/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/karimmattar/domainkit/blob/main/docs/reference.md
+Project-URL: Homepage, https://github.com/karimmattar/domainkit
+Project-URL: Issues, https://github.com/karimmattar/domainkit/issues
+Description-Content-Type: text/markdown
+
+# domainkit
+
+A Django-style framework for domain-driven FastAPI services. It provides:
+
+- settings modules and installed domains
+- `manage.py` commands and migrations
+- DDD building blocks, with the layer rules between them enforced
+- optional apps for reliable messaging, audit trails, and idempotent requests
+
+```bash
+pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, tracing
+```
+
+## Documentation
+
+- [docs/reference.md](https://github.com/karimmattar/domainkit/blob/main/docs/reference.md): settings, middleware, errors,
+  observability, testing, commands, and extension points
+- [docs/contrib.md](https://github.com/karimmattar/domainkit/blob/main/docs/contrib.md): messaging, audit, and idempotency
+- [docs/versioning.md](https://github.com/karimmattar/domainkit/blob/main/docs/versioning.md): compatibility, deprecations, and releases
+- [docs/adr/](https://github.com/karimmattar/domainkit/tree/main/docs/adr): the decisions behind the design
+- [CHANGELOG.md](https://github.com/karimmattar/domainkit/blob/main/CHANGELOG.md) and [SECURITY.md](https://github.com/karimmattar/domainkit/blob/main/SECURITY.md)
+
+## Quick start
+
+A project is a `pyproject.toml`, a `manage.py`, a `config` package, and a
+`domains` package for its bounded contexts. The project's name sets the
+environment variable prefix: `billingAPI` reads `BILLING_API_*`.
+
+```text
+billing/
+  pyproject.toml
+  manage.py
+  src/config/__init__.py
+  src/config/settings/__init__.py
+  src/config/settings/local.py
+  src/config/settings/test.py
+  src/config/urls.py
+  src/config/asgi.py
+  src/domains/__init__.py
+```
+
+```toml
+# pyproject.toml
+[project]
+name = "billingAPI"
+version = "0.1.0"
+requires-python = ">=3.13"
+dependencies = ["domainkit[sqlite]"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "-p domainkit.testing"           # the database and client fixtures
+domainkit_settings = "config.settings.test"
+```
+
+```python
+# manage.py
+import sys
+from pathlib import Path
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(Path(__file__).resolve().parent / "src"))
+    from domainkit.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)
+```
+
+```python
+# src/config/settings/local.py
+from pathlib import Path
+
+from domainkit.conf.env import Env
+
+env = Env()
+BASE_DIR = Path(__file__).resolve().parents[3]
+
+DEBUG = True
+INSTALLED_DOMAINS = ["domainkit.contrib.messaging"]
+ROOT_ROUTER = "config.urls.router"
+ASGI_APPLICATION = "config.asgi:application"
+DATABASES = {
+    "default": {
+        "URL": env.str("DATABASE_URL", f"sqlite+aiosqlite:///{BASE_DIR / 'db.sqlite3'}")
+    },
+}
+```
+
+```python
+# src/config/settings/test.py
+from config.settings.local import *
+
+DEBUG = False
+ALLOWED_HOSTS = ["testserver"]
+DATABASES = {"default": {"URL": "sqlite+aiosqlite:///:memory:"}}
+```
+
+```python
+# src/config/urls.py
+from fastapi import APIRouter
+
+from domainkit.http.health import router as health_router
+
+router = APIRouter()
+router.include_router(health_router)
+```
+
+```python
+# src/config/asgi.py
+from domainkit.http import get_asgi_application
+
+application = get_asgi_application()
+```
+
+Then:
+
+```bash
+export BILLING_API_SETTINGS_MODULE=config.settings.local   # or put it in .env
+python manage.py check
+python manage.py startdomain invoices --aggregate Invoice   # prints how to install it
+python manage.py makemigrations -m "create invoices" && python manage.py migrate
+pytest                                                      # the generated tests
+python manage.py runserver                                  # http://127.0.0.1:8000/docs
+```
+
+## Developing domainkit
+
+```bash
+poetry install --all-extras            # Python 3.13
+pre-commit install                     # after: pipx install pre-commit
+
+poetry run ruff check . && poetry run ruff format --check . && poetry run mypy
+poetry run pytest --cov                # random order; coverage gate in pyproject.toml
+poetry run mutmut run "domainkit.http*" && poetry run mutmut results
+```
+
+CI (`.github/workflows/ci.yml`) runs the same checks on every push and pull
+request:
+
+- lint and strict typing
+- the tests on Python 3.13 and 3.14
+- a wheel build, installed and imported in a clean environment
+- pip-audit, and a gitleaks scan of the whole history
+
+A full mutation testing run happens weekly. Releases are published to PyPI
+from a version tag; see [docs/versioning.md](https://github.com/karimmattar/domainkit/blob/main/docs/versioning.md).
+
+## License
+
+MIT; see [LICENSE](https://github.com/karimmattar/domainkit/blob/main/LICENSE).
+

domainkit-0.1.0/README.md

@@ -0,0 +1,149 @@
+# domainkit
+
+A Django-style framework for domain-driven FastAPI services. It provides:
+
+- settings modules and installed domains
+- `manage.py` commands and migrations
+- DDD building blocks, with the layer rules between them enforced
+- optional apps for reliable messaging, audit trails, and idempotent requests
+
+```bash
+pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, tracing
+```
+
+## Documentation
+
+- [docs/reference.md](https://github.com/karimmattar/domainkit/blob/main/docs/reference.md): settings, middleware, errors,
+  observability, testing, commands, and extension points
+- [docs/contrib.md](https://github.com/karimmattar/domainkit/blob/main/docs/contrib.md): messaging, audit, and idempotency
+- [docs/versioning.md](https://github.com/karimmattar/domainkit/blob/main/docs/versioning.md): compatibility, deprecations, and releases
+- [docs/adr/](https://github.com/karimmattar/domainkit/tree/main/docs/adr): the decisions behind the design
+- [CHANGELOG.md](https://github.com/karimmattar/domainkit/blob/main/CHANGELOG.md) and [SECURITY.md](https://github.com/karimmattar/domainkit/blob/main/SECURITY.md)
+
+## Quick start
+
+A project is a `pyproject.toml`, a `manage.py`, a `config` package, and a
+`domains` package for its bounded contexts. The project's name sets the
+environment variable prefix: `billingAPI` reads `BILLING_API_*`.
+
+```text
+billing/
+  pyproject.toml
+  manage.py
+  src/config/__init__.py
+  src/config/settings/__init__.py
+  src/config/settings/local.py
+  src/config/settings/test.py
+  src/config/urls.py
+  src/config/asgi.py
+  src/domains/__init__.py
+```
+
+```toml
+# pyproject.toml
+[project]
+name = "billingAPI"
+version = "0.1.0"
+requires-python = ">=3.13"
+dependencies = ["domainkit[sqlite]"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "-p domainkit.testing"           # the database and client fixtures
+domainkit_settings = "config.settings.test"
+```
+
+```python
+# manage.py
+import sys
+from pathlib import Path
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(Path(__file__).resolve().parent / "src"))
+    from domainkit.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)
+```
+
+```python
+# src/config/settings/local.py
+from pathlib import Path
+
+from domainkit.conf.env import Env
+
+env = Env()
+BASE_DIR = Path(__file__).resolve().parents[3]
+
+DEBUG = True
+INSTALLED_DOMAINS = ["domainkit.contrib.messaging"]
+ROOT_ROUTER = "config.urls.router"
+ASGI_APPLICATION = "config.asgi:application"
+DATABASES = {
+    "default": {
+        "URL": env.str("DATABASE_URL", f"sqlite+aiosqlite:///{BASE_DIR / 'db.sqlite3'}")
+    },
+}
+```
+
+```python
+# src/config/settings/test.py
+from config.settings.local import *
+
+DEBUG = False
+ALLOWED_HOSTS = ["testserver"]
+DATABASES = {"default": {"URL": "sqlite+aiosqlite:///:memory:"}}
+```
+
+```python
+# src/config/urls.py
+from fastapi import APIRouter
+
+from domainkit.http.health import router as health_router
+
+router = APIRouter()
+router.include_router(health_router)
+```
+
+```python
+# src/config/asgi.py
+from domainkit.http import get_asgi_application
+
+application = get_asgi_application()
+```
+
+Then:
+
+```bash
+export BILLING_API_SETTINGS_MODULE=config.settings.local   # or put it in .env
+python manage.py check
+python manage.py startdomain invoices --aggregate Invoice   # prints how to install it
+python manage.py makemigrations -m "create invoices" && python manage.py migrate
+pytest                                                      # the generated tests
+python manage.py runserver                                  # http://127.0.0.1:8000/docs
+```
+
+## Developing domainkit
+
+```bash
+poetry install --all-extras            # Python 3.13
+pre-commit install                     # after: pipx install pre-commit
+
+poetry run ruff check . && poetry run ruff format --check . && poetry run mypy
+poetry run pytest --cov                # random order; coverage gate in pyproject.toml
+poetry run mutmut run "domainkit.http*" && poetry run mutmut results
+```
+
+CI (`.github/workflows/ci.yml`) runs the same checks on every push and pull
+request:
+
+- lint and strict typing
+- the tests on Python 3.13 and 3.14
+- a wheel build, installed and imported in a clean environment
+- pip-audit, and a gitleaks scan of the whole history
+
+A full mutation testing run happens weekly. Releases are published to PyPI
+from a version tag; see [docs/versioning.md](https://github.com/karimmattar/domainkit/blob/main/docs/versioning.md).
+
+## License
+
+MIT; see [LICENSE](https://github.com/karimmattar/domainkit/blob/main/LICENSE).

domainkit-0.1.0/pyproject.toml

@@ -0,0 +1,125 @@
+[project]
+name = "domainkit"
+version = "0.1.0"
+description = "A Django-style framework for domain-driven FastAPI services."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.13,<4"
+authors = [
+    {name = "karim magdy", email = "karimhady111@gmail.com"},
+]
+keywords = ["ddd", "domain-driven-design", "fastapi", "sqlalchemy", "outbox", "framework"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Typing :: Typed",
+]
+# Everything domainkit imports. Database drivers are extras: projects pick.
+dependencies = [
+    "fastapi (>=0.141.1,<0.142.0)",
+    "uvicorn[standard] (>=0.54.0,<0.55.0)",
+    "pydantic (>=2.14.1,<3.0.0)",
+    "sqlalchemy[asyncio] (>=2.0.54,<2.1)",
+    "alembic (>=1.20.0,<2.0.0)",
+    "python-dotenv (>=1.2.4,<2.0.0)",
+]
+
+[project.optional-dependencies]
+postgres = ["asyncpg (>=0.31.0,<0.32.0)"]
+sqlite = ["aiosqlite (>=0.22.1,<0.23.0)"]
+metrics = ["prometheus-client (>=0.26.0,<0.27.0)"]
+tracing = ["opentelemetry-api (>=1.45.1,<2.0.0)"]
+
+[project.urls]
+Homepage = "https://github.com/karimmattar/domainkit"
+Documentation = "https://github.com/karimmattar/domainkit/blob/main/docs/reference.md"
+Changelog = "https://github.com/karimmattar/domainkit/blob/main/CHANGELOG.md"
+Issues = "https://github.com/karimmattar/domainkit/issues"
+
+[build-system]
+# 2.2.1 is the version verified to write PEP 639 license metadata.
+requires = ["poetry-core>=2.2.1,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+packages = [{ include = "domainkit", from = "src" }]
+
+# poetry install --all-extras: the tests exercise every driver and integration.
+[dependency-groups]
+dev = [
+    "pytest (>=9.1.1,<10.0.0)",
+    "pytest-cov (>=7.1.0,<8.0.0)",
+    "ruff (>=0.16.8,<0.17.0)",
+    "mypy (>=2.3.1,<3.0.0)",
+    "pip-audit (>=2.9.0,<3.0.0)",
+    # Starlette's TestClient (it deprecates plain httpx).
+    "httpx2 (>=2.13.0,<3.0.0)",
+    # In-memory span exporter for the tracing tests.
+    "opentelemetry-sdk (>=1.45.1,<2.0.0)",
+    # Random test order, property-based tests, mutation testing.
+    "pytest-randomly (>=5.0.0,<6.0.0)",
+    "hypothesis (>=6.169.0,<7.0.0)",
+    "mutmut (>=3.8.0,<4.0.0)",
+]
+
+[tool.ruff]
+target-version = "py313"
+line-length = 88
+src = ["src", "."]
+extend-exclude = ["src/domainkit/management/templates", "**/mutants"]
+
+[tool.ruff.lint]
+# S: security (bandit), ASYNC: blocking calls in async code, BLE: blind except,
+# G/LOG: logging misuse, DTZ: naive datetimes, T20: stray prints.
+select = [
+    "E", "F", "I", "UP", "B", "SIM", "D", "ANN", "RUF",
+    "S", "ASYNC", "BLE", "G", "LOG", "DTZ", "T20",
+    "PT", "C4", "RET", "PIE", "PERF", "PTH", "ERA", "ISC",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+# Tests assert, and use throwaway credentials and server-side identifiers.
+"domainkit_tests/**" = ["S101", "S105", "S106"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+plugins = ["pydantic.mypy"]
+mypy_path = "src:."
+files = ["src", "domainkit_tests"]
+exclude = ["/management/templates/", "/mutants/"]
+
+[tool.pytest.ini_options]
+testpaths = ["domainkit_tests"]
+pythonpath = ["."]
+# pytester: the testing plugin is checked by running a pytest session in a test.
+addopts = "-ra --strict-markers --strict-config -p pytester"
+filterwarnings = ["error"]
+
+[tool.coverage.run]
+branch = true
+concurrency = ["thread", "greenlet"]
+source = ["src"]
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
+fail_under = 98
+precision = 2
+exclude_also = ["if TYPE_CHECKING:", "raise NotImplementedError"]
+
+# Mutation testing: "mutmut run 'domainkit.utils*'" (one area at a time; a
+# full run takes a while), then "mutmut results".
+[tool.mutmut]
+source_paths = ["src"]
+also_copy = ["domainkit_tests/", "docs/"]
+pytest_add_cli_args_test_selection = ["domainkit_tests/", "-p", "no:randomly"]

domainkit-0.1.0/src/domainkit/__init__.py

@@ -0,0 +1,40 @@
+"""domainkit: a Django-style framework for domain-driven FastAPI services.
+
+Layers, lowest first; a module may import only from its own layer or below:
+
+1. ``exceptions``, ``utils``, ``ddd``: no settings, no I/O. ``ddd`` holds the
+   domain building blocks (entities, value objects, events, repositories).
+2. ``conf``: settings loading and validation.
+3. ``apps``, ``context``, ``log``, ``reporting``: the domain registry and
+   observability.
+4. ``db``, ``http``: SQLAlchemy and FastAPI integration.
+5. ``management``: the ``manage.py`` commands.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("domainkit")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0+unknown"
+
+
+def setup() -> None:
+    """Configure logging and load the installed domains (``django.setup()``).
+
+    Safe to call more than once; later calls do nothing.
+    """
+    from domainkit.apps import registry
+    from domainkit.conf import settings
+    from domainkit.ddd import event_bus
+    from domainkit.log import configure_logging
+    from domainkit.reporting import report_error, reporters
+
+    if registry.ready:
+        return
+    configure_logging(settings.LOGGING)
+    reporters()
+    event_bus.error_hook = lambda exc, event: report_error(
+        exc, event=type(event).__qualname__, event_id=str(event.event_id)
+    )
+    registry.populate(settings.INSTALLED_DOMAINS)

domainkit-0.1.0/src/domainkit/apps/__init__.py

@@ -0,0 +1,6 @@
+"""Installed domains (``django.apps``): configuration classes and the registry."""
+
+from domainkit.apps.config import DomainConfig
+from domainkit.apps.registry import DomainRegistry, registry
+
+__all__ = ["DomainConfig", "DomainRegistry", "registry"]

domainkit-0.1.0/src/domainkit/apps/config.py

@@ -0,0 +1,118 @@
+"""``DomainConfig``: Django's ``AppConfig`` for a bounded context."""
+
+from collections.abc import Sequence
+from importlib import import_module
+from pathlib import Path
+from types import ModuleType
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from domainkit.exceptions import ImproperlyConfigured
+
+if TYPE_CHECKING:
+    from domainkit.ddd import DeferredTask, DomainEvent, UnitOfWork
+
+CONFIG_MODULE = "apps"
+
+
+class DomainConfig:
+    """Describe one installed domain and its lifecycle hooks.
+
+    Each domain package may define exactly one subclass in its ``apps``
+    module; a package without one gets this base class. Override only the
+    hooks the domain needs.
+    """
+
+    label: str = ""
+    """Unique short name; defaults to the last part of the package path."""
+    verbose_name: str = ""
+    settings_class: type[BaseModel] | None = None
+    """Schema for this domain's settings, read from ``settings_name``."""
+
+    def __init__(self, name: str, module: ModuleType) -> None:
+        """Bind the config to the domain package ``name``."""
+        self.name = name
+        self.module = module
+        self.label = self.label or name.rpartition(".")[2]
+        if not self.label.isidentifier():
+            raise ImproperlyConfigured(
+                f"Domain label {self.label!r} is not a valid Python identifier."
+            )
+        self.verbose_name = self.verbose_name or self.label.replace("_", " ").title()
+
+    def __repr__(self) -> str:
+        """Show the class and the domain label."""
+        return f"<{type(self).__name__}: {self.label}>"
+
+    @property
+    def settings_name(self) -> str:
+        """Settings-module name holding this domain's settings, e.g. ``BILLING``."""
+        return self.label.upper()
+
+    @property
+    def path(self) -> Path:
+        """Directory of the domain package."""
+        return Path(next(iter(self.module.__path__)))
+
+    @classmethod
+    def create(cls, name: str) -> "DomainConfig":
+        """Import package ``name`` and instantiate its ``DomainConfig``."""
+        module = _import_domain(name)
+        config_module_name = f"{name}.{CONFIG_MODULE}"
+        try:
+            config_module = import_module(config_module_name)
+        except ModuleNotFoundError as exc:
+            if exc.name != config_module_name:
+                raise
+            return cls(name, module)
+        configs = [
+            value
+            for value in vars(config_module).values()
+            if isinstance(value, type)
+            and issubclass(value, DomainConfig)
+            and value.__module__ == config_module_name
+        ]
+        if len(configs) != 1:
+            raise ImproperlyConfigured(
+                f"{config_module_name!r} must define exactly one DomainConfig "
+                f"subclass, found {len(configs)}."
+            )
+        return configs[0](name, module)
+
+    def ready(self) -> None:
+        """Wire the domain once settings are loaded: ORM mappers, event handlers."""
+
+    async def startup(self) -> None:
+        """Open process resources such as clients and pools."""
+
+    async def shutdown(self) -> None:
+        """Release resources opened by ``startup``."""
+
+    async def check(self) -> None:
+        """Raise when the domain cannot serve traffic (readiness probe)."""
+
+    async def stage(
+        self,
+        uow: "UnitOfWork",
+        events: Sequence["DomainEvent"],
+        tasks: Sequence["DeferredTask"],
+    ) -> None:
+        """Add rows to a committing SQL unit of work (outbox, audit trail)."""
+
+
+def _import_domain(name: str) -> ModuleType:
+    """Import a domain package, explaining a missing one."""
+    try:
+        module = import_module(name)
+    except ModuleNotFoundError as exc:
+        if exc.name is not None and (
+            name == exc.name or name.startswith(f"{exc.name}.")
+        ):
+            raise ImproperlyConfigured(
+                f"Installed domain {name!r} cannot be imported."
+            ) from exc
+        raise
+    if not hasattr(module, "__path__"):
+        raise ImproperlyConfigured(f"Installed domain {name!r} must be a package.")
+    return module