domainkit 0.1.0__tar.gz → 0.2.0__tar.gz

{domainkit-0.1.0 → domainkit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: domainkit
-Version: 0.1.0
+Version: 0.2.0
 Summary: A Django-style framework for domain-driven FastAPI services.
 License-Expression: MIT
 License-File: LICENSE
@@ -19,14 +19,17 @@ Classifier: Typing :: Typed
 Provides-Extra: metrics
 Provides-Extra: postgres
 Provides-Extra: sqlite
+Provides-Extra: testing
 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: httpx2 (>=2.13.0,<3.0.0) ; extra == "testing"
 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: pytest (>=9.1.1,<10.0.0) ; extra == "testing"
 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)
@@ -46,7 +49,7 @@ A Django-style framework for domain-driven FastAPI services. It provides:
 - optional apps for reliable messaging, audit trails, and idempotent requests
 
 ```bash
-pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, tracing
+pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, tracing, testing
 ```
 
 ## Documentation
@@ -60,105 +63,36 @@ pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, traci
 
 ## 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_*`.
+```bash
+python3.13 -m venv .venv && . .venv/bin/activate
+pip install "domainkit[postgres,sqlite,testing]"
+domainkit init billingAPI billing     # the name sets the variable prefix: BILLING_API_*
+cd billing
+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
+python manage.py runserver            # http://127.0.0.1:8000/docs
+```
+
+`domainkit init` creates a project that passes `check` and its tests as it is:
 
 ```text
 billing/
-  pyproject.toml
+  pyproject.toml          the name, dependencies, and the pytest plugin
   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"
+  .env                    selects config.settings.local on this machine
+  .gitignore
+  src/config/settings/    base, local, test, and production settings
+  src/config/urls.py      the root router: mount each domain's router here
+  src/config/asgi.py      the application, for uvicorn
+  src/domains/            the bounded contexts
+  tests/test_health.py
 ```
 
-```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
-```
+The production settings read `BILLING_API_ALLOWED_HOSTS` and
+`BILLING_API_DATABASE_URL` from the environment, and the deployment checks
+refuse to start without them, or without verified TLS to the database.
 
 ## Developing domainkit
 
@@ -171,11 +105,24 @@ poetry run pytest --cov                # random order; coverage gate in pyprojec
 poetry run mutmut run "domainkit.http*" && poetry run mutmut results
 ```
 
+The database tests use SQLite unless `DOMAINKIT_TEST_POSTGRES_URL` names a
+PostgreSQL server; each test then creates a database there and drops it.
+Use a throwaway server:
+
+```bash
+docker run -d --rm --name domainkit-postgres -e POSTGRES_PASSWORD=postgres \
+  -p 127.0.0.1:55432:5432 postgres:18-alpine
+DOMAINKIT_TEST_POSTGRES_URL=postgresql+asyncpg://postgres:postgres@127.0.0.1:55432/postgres \
+  poetry run pytest
+```
+
 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
+- the tests again with PostgreSQL 18, including row locking, the audit
+  triggers, and server-side timeouts
 - a wheel build, installed and imported in a clean environment
 - pip-audit, and a gitleaks scan of the whole history
 

{domainkit-0.1.0 → domainkit-0.2.0}/README.md

@@ -8,7 +8,7 @@ A Django-style framework for domain-driven FastAPI services. It provides:
 - optional apps for reliable messaging, audit trails, and idempotent requests
 
 ```bash
-pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, tracing
+pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, tracing, testing
 ```
 
 ## Documentation
@@ -22,105 +22,36 @@ pip install "domainkit[postgres]"     # extras: postgres, sqlite, metrics, traci
 
 ## 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_*`.
+```bash
+python3.13 -m venv .venv && . .venv/bin/activate
+pip install "domainkit[postgres,sqlite,testing]"
+domainkit init billingAPI billing     # the name sets the variable prefix: BILLING_API_*
+cd billing
+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
+python manage.py runserver            # http://127.0.0.1:8000/docs
+```
+
+`domainkit init` creates a project that passes `check` and its tests as it is:
 
 ```text
 billing/
-  pyproject.toml
+  pyproject.toml          the name, dependencies, and the pytest plugin
   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"
+  .env                    selects config.settings.local on this machine
+  .gitignore
+  src/config/settings/    base, local, test, and production settings
+  src/config/urls.py      the root router: mount each domain's router here
+  src/config/asgi.py      the application, for uvicorn
+  src/domains/            the bounded contexts
+  tests/test_health.py
 ```
 
-```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
-```
+The production settings read `BILLING_API_ALLOWED_HOSTS` and
+`BILLING_API_DATABASE_URL` from the environment, and the deployment checks
+refuse to start without them, or without verified TLS to the database.
 
 ## Developing domainkit
 
@@ -133,11 +64,24 @@ poetry run pytest --cov                # random order; coverage gate in pyprojec
 poetry run mutmut run "domainkit.http*" && poetry run mutmut results
 ```
 
+The database tests use SQLite unless `DOMAINKIT_TEST_POSTGRES_URL` names a
+PostgreSQL server; each test then creates a database there and drops it.
+Use a throwaway server:
+
+```bash
+docker run -d --rm --name domainkit-postgres -e POSTGRES_PASSWORD=postgres \
+  -p 127.0.0.1:55432:5432 postgres:18-alpine
+DOMAINKIT_TEST_POSTGRES_URL=postgresql+asyncpg://postgres:postgres@127.0.0.1:55432/postgres \
+  poetry run pytest
+```
+
 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
+- the tests again with PostgreSQL 18, including row locking, the audit
+  triggers, and server-side timeouts
 - a wheel build, installed and imported in a clean environment
 - pip-audit, and a gitleaks scan of the whole history
 

{domainkit-0.1.0 → domainkit-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "domainkit"
-version = "0.1.0"
+version = "0.2.0"
 description = "A Django-style framework for domain-driven FastAPI services."
 readme = "README.md"
 license = "MIT"
@@ -35,6 +35,12 @@ 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)"]
+# The domainkit.testing pytest plugin; Starlette's TestClient needs httpx2.
+testing = ["pytest (>=9.1.1,<10.0.0)", "httpx2 (>=2.13.0,<3.0.0)"]
+
+# Runs commands before a project exists: "domainkit init billingAPI".
+[project.scripts]
+domainkit = "domainkit.management:execute_from_command_line"
 
 [project.urls]
 Homepage = "https://github.com/karimmattar/domainkit"

{domainkit-0.1.0 → domainkit-0.2.0}/src/domainkit/contrib/audit/protection.py

@@ -2,8 +2,9 @@
 
 Revoking ``UPDATE`` and ``DELETE`` from the application's role is undone by
 the next broad ``GRANT``. These triggers refuse updates, deletes, and
-truncation for every role but the table owner, who alone can drop them (for
-example, to apply a retention policy). Call them from a project revision::
+truncation for every role, the table owner included; only the owner can drop
+them (for example, to apply a retention policy). Call them from a project
+revision::
 
     from domainkit.contrib.audit.protection import protect, unprotect
 

domainkit-0.2.0/src/domainkit/management/commands/init.py

@@ -0,0 +1,108 @@
+"""``init``: create a project from the project template (Django's ``startproject``).
+
+It runs before any project exists, through the ``domainkit`` program the
+package installs::
+
+    domainkit init billingAPI            # creates ./billingAPI
+    domainkit init billingAPI billing    # or names the directory
+
+The project gets settings for local work, tests, and production; its routes
+and ASGI application; ``manage.py``; and a first test. Its name sets the
+environment variable prefix (``billingAPI``: ``BILLING_API_``).
+"""
+
+import re
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import Final
+
+from domainkit import __version__
+from domainkit.conf.env import prefix_for
+from domainkit.management.base import BaseCommand, CommandError
+from domainkit.management.commands.startdomain import render
+from domainkit.utils.formatting import format_python
+
+TEMPLATE_DIR: Final = Path(__file__).resolve().parents[1] / "templates" / "project"
+DOTFILE: Final = "dot-"
+"""Template files named ``dot-<name>`` become ``.<name>`` (``.env``, ``.gitignore``)."""
+_PROJECT_NAME: Final = re.compile(r"[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?")
+_RELEASE: Final = re.compile(r"(\d+)\.(\d+)\.\d+")
+
+
+def requirement(version: str) -> str:
+    """Depend on this release up to the next one that may break it.
+
+    Before 1.0 a minor release may break (``>=0.1.1,<0.2``); after it, a
+    major one. A version without release numbers (a source checkout) pins
+    nothing.
+    """
+    extras = "domainkit[postgres,sqlite]"
+    match = _RELEASE.fullmatch(version)
+    if match is None:
+        return extras
+    major, minor = int(match[1]), int(match[2])
+    upper = f"0.{minor + 1}" if major == 0 else f"{major + 1}"
+    return f"{extras}>={version},<{upper}"
+
+
+class Command(BaseCommand):
+    """Generate a project directory that passes ``check`` and its tests."""
+
+    help = "Create a project: settings, routes, manage.py, and a first test."
+    requires_setup = False
+
+    def add_arguments(self, parser: ArgumentParser) -> None:
+        """Accept the project name and an optional directory."""
+        parser.add_argument(
+            "name",
+            help="project name, as in [project].name; it sets the environment "
+            "variable prefix (billingAPI: BILLING_API_)",
+        )
+        parser.add_argument(
+            "directory",
+            nargs="?",
+            type=Path,
+            help="where to create it (default: ./<name>); empty or missing",
+        )
+
+    def handle(self, *, name: str, directory: Path | None, **options: object) -> None:
+        """Render the template, then print the next steps."""
+        if not _PROJECT_NAME.fullmatch(name):
+            raise CommandError(
+                f"{name!r} is not a valid project name: use letters, digits, '.', "
+                "'-', and '_', starting and ending with a letter or digit."
+            )
+        prefix = prefix_for(name)
+        if not prefix[0].isalpha():
+            raise CommandError(
+                f"{name!r} must start with a letter: it prefixes the project's "
+                f"environment variables ({prefix}...)."
+            )
+        target = (directory or Path(name)).resolve()
+        if target.exists() and (not target.is_dir() or any(target.iterdir())):
+            raise CommandError(f"{target} already exists and is not empty.")
+        context = {
+            "project": name,
+            "prefix": prefix,
+            "dependency": requirement(__version__),
+        }
+        for path in render(TEMPLATE_DIR, target, context):
+            if path.name.startswith(DOTFILE):
+                path.rename(path.with_name(f".{path.name.removeprefix(DOTFILE)}"))
+        format_python([target])
+        self.write(_next_steps(name, target))
+
+
+def _next_steps(name: str, target: Path) -> str:
+    """Explain how to install and run the new project."""
+    return "\n".join(
+        [
+            f"Created {name} in {target}.",
+            "Next steps:",
+            f"  cd {target.relative_to(Path.cwd(), walk_up=True)}",
+            '  pip install "domainkit[postgres,sqlite,testing]"   # or: uv sync',
+            "  python manage.py check",
+            "  python manage.py startdomain <name>",
+            "  pytest",
+        ]
+    )

domainkit-0.2.0/src/domainkit/management/templates/project/dot-env-tpl

@@ -0,0 +1,3 @@
+# This machine's settings. Never commit or deploy this file: deployments set
+# {{ prefix }}SETTINGS_MODULE themselves.
+{{ prefix }}SETTINGS_MODULE=config.settings.local

domainkit-0.2.0/src/domainkit/management/templates/project/dot-gitignore-tpl

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+dist/
+.env
+*.sqlite3

domainkit-0.2.0/src/domainkit/management/templates/project/manage.py-tpl

@@ -0,0 +1,15 @@
+"""Run the project's commands: python manage.py <command>."""
+
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+
+if __name__ == "__main__":
+    # Find pyproject.toml and .env whatever the working directory.
+    os.environ.setdefault("DOMAINKIT_PROJECT_ROOT", str(ROOT))
+    sys.path.insert(0, str(ROOT / "src"))
+    from domainkit.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)

domainkit-0.2.0/src/domainkit/management/templates/project/pyproject.toml-tpl

@@ -0,0 +1,17 @@
+[project]
+name = "{{ project }}"
+version = "0.1.0"
+requires-python = ">=3.13"
+dependencies = ["{{ dependency }}"]
+
+[dependency-groups]
+dev = ["domainkit[testing]"]                # pytest and httpx2, for the fixtures
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "-p domainkit.testing"           # the database and client fixtures
+domainkit_settings = "config.settings.test"
+
+[tool.ruff.lint.per-file-ignores]
+# Each settings module builds on base.py with a star import.
+"src/config/settings/*.py" = ["F403", "F405"]

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/__init__.py-tpl

@@ -0,0 +1 @@
+"""Project configuration: settings, routes, and the ASGI application."""

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/asgi.py-tpl

@@ -0,0 +1,5 @@
+"""The ASGI application, for uvicorn: config.asgi:application."""
+
+from domainkit.http import get_asgi_application
+
+application = get_asgi_application()

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/settings/__init__.py-tpl

@@ -0,0 +1 @@
+"""Settings modules; {{ prefix }}SETTINGS_MODULE selects one."""

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/settings/base.py-tpl

@@ -0,0 +1,13 @@
+"""Settings shared by every environment."""
+
+from pathlib import Path
+
+from domainkit.conf.env import Env
+
+env = Env()
+BASE_DIR = Path(__file__).resolve().parents[3]
+
+PROJECT_NAME = "{{ project }}"
+INSTALLED_DOMAINS = ["domainkit.contrib.messaging"]
+ROOT_ROUTER = "config.urls.router"
+ASGI_APPLICATION = "config.asgi:application"

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/settings/local.py-tpl

@@ -0,0 +1,11 @@
+"""Settings for development on this machine (selected by .env)."""
+
+from config.settings.base import *
+from config.settings.base import BASE_DIR, env
+
+DEBUG = True
+DATABASES = {
+    "default": {
+        "URL": env.str("DATABASE_URL", f"sqlite+aiosqlite:///{BASE_DIR / 'db.sqlite3'}")
+    },
+}

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/settings/production.py-tpl

@@ -0,0 +1,16 @@
+"""Settings for production: addresses and secrets come from the environment.
+
+Set {{ prefix }}SETTINGS_MODULE=config.settings.production,
+{{ prefix }}ALLOWED_HOSTS (comma-separated), and {{ prefix }}DATABASE_URL.
+Startup fails when one is missing, and the deployment checks refuse DEBUG,
+wildcard hosts, and network databases without verified TLS.
+"""
+
+from config.settings.base import *
+from config.settings.base import env
+
+ENVIRONMENT = "production"
+ALLOWED_HOSTS = env.list("ALLOWED_HOSTS")
+DATABASES = {
+    "default": {"URL": env.str("DATABASE_URL"), "SSLMODE": "verify-full"},
+}

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/settings/test.py-tpl

@@ -0,0 +1,7 @@
+"""Settings for the tests (domainkit_settings in pyproject.toml)."""
+
+from config.settings.base import *
+
+ENVIRONMENT = "test"
+ALLOWED_HOSTS = ["testserver"]
+DATABASES = {"default": {"URL": "sqlite+aiosqlite:///:memory:"}}

domainkit-0.2.0/src/domainkit/management/templates/project/src/config/urls.py-tpl

@@ -0,0 +1,8 @@
+"""The project's routes: mount each domain's router here."""
+
+from fastapi import APIRouter
+
+from domainkit.http.health import router as health_router
+
+router = APIRouter()
+router.include_router(health_router)

domainkit-0.2.0/src/domainkit/management/templates/project/src/domains/__init__.py-tpl

@@ -0,0 +1 @@
+"""The bounded contexts; add one with: python manage.py startdomain <name>."""

domainkit-0.2.0/src/domainkit/management/templates/project/tests/__init__.py-tpl

@@ -0,0 +1 @@
+"""The project's tests."""

domainkit-0.2.0/src/domainkit/management/templates/project/tests/test_health.py-tpl

@@ -0,0 +1,8 @@
+"""The application starts and answers its liveness probe."""
+
+from fastapi.testclient import TestClient
+
+
+def test_health(client: TestClient) -> None:
+    """GET /health answers 200."""
+    assert client.get("/health").status_code == 200

{domainkit-0.1.0 → domainkit-0.2.0}/src/domainkit/utils/formatting.py

@@ -18,9 +18,10 @@ def format_python(paths: Iterable[Path]) -> bool:
         return False
     targets = [str(path) for path in paths]
     ruff = [sys.executable, "-m", "ruff"]
+    # No cache: it would land in a project that was just generated.
     for arguments in (
-        ["check", "--fix", "--select", "I", "--quiet", *targets],
-        ["format", "--quiet", *targets],
+        ["check", "--fix", "--select", "I", "--quiet", "--no-cache", *targets],
+        ["format", "--quiet", "--no-cache", *targets],
     ):
         subprocess.run([*ruff, *arguments], check=False)  # noqa: S603 - fixed program, generated paths.
     return True