python-ddd-framework 0.3.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

python_ddd_framework/caching/contracts.py

@@ -1,73 +1,71 @@
-"""强制 TTL 的 typed cache definition 与最小读写契约。"""
+"""注入时确定值类型的缓存契约。"""
 
-from __future__ import annotations
+from collections.abc import Awaitable, Callable, Iterable
+from typing import Protocol, TypeVar
 
-from datetime import timedelta
-from typing import Any, Generic, Protocol, TypeVar
-
-from pydantic import TypeAdapter
-
-from .errors import CacheDefinitionError
+from .options import DistributedCacheEntryOptions
 
 _T = TypeVar("_T")
 
 
-class CacheDefinition(Generic[_T]):
-    __slots__ = ("_adapter", "_name", "_ttl", "_value_type")
-
-    def __init__(self, name: str, value_type: type[_T], *, ttl: timedelta) -> None:
-        if (
-            not isinstance(name, str)
-            or not name
-            or name != name.strip()
-            or name.startswith(":")
-            or name.endswith(":")
-            or "::" in name
-            # ':' 是 Redis key 的结构分隔符，definition name 不得制造跨 cache key 歧义。
-            or any(not (item.isalnum() or item in "._-") for item in name)
-        ):
-            raise CacheDefinitionError(
-                cache=name if isinstance(name, str) else repr(name),
-                reason="name must be a trimmed cache identifier",
-            )
-        if not isinstance(value_type, type):
-            raise CacheDefinitionError(cache=name, reason="value_type must be a runtime type")
-        if not isinstance(ttl, timedelta) or ttl.total_seconds() <= 0:
-            raise CacheDefinitionError(cache=name, reason="ttl must be a positive timedelta")
-        if ttl.total_seconds() > 2_147_483_647:
-            raise CacheDefinitionError(cache=name, reason="ttl exceeds the supported Redis range")
-        self._name = name
-        self._value_type = value_type
-        self._ttl = ttl
-        self._adapter: TypeAdapter[_T] = TypeAdapter(value_type)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def value_type(self) -> type[_T]:
-        return self._value_type
-
-    @property
-    def ttl(self) -> timedelta:
-        return self._ttl
-
-    def __repr__(self) -> str:
-        return (
-            f"CacheDefinition(name={self.name!r}, value_type={self.value_type!r}, ttl={self.ttl!r})"
-        )
-
-    def _serialize(self, value: _T) -> bytes:
-        return self._adapter.dump_json(self._adapter.validate_python(value))
-
-    def _deserialize(self, value: bytes | str) -> _T:
-        return self._adapter.validate_json(value)
-
-
-class DistributedCache(Protocol):
-    async def get(self, definition: CacheDefinition[_T], key: str) -> _T | None: ...
-
-    async def set(self, definition: CacheDefinition[_T], key: str, value: _T) -> None: ...
-
-    async def remove(self, definition: CacheDefinition[Any], key: str) -> None: ...
+class DistributedCache(Protocol[_T]):
+    async def get(
+        self, key: str, *, hide_errors: bool | None = None, consider_uow: bool = False
+    ) -> _T | None: ...
+
+    async def get_many(
+        self, keys: Iterable[str], *, hide_errors: bool | None = None, consider_uow: bool = False
+    ) -> list[tuple[str, _T | None]]: ...
+
+    async def get_or_add(
+        self,
+        key: str,
+        factory: Callable[[], Awaitable[_T | None]],
+        *,
+        options_factory: Callable[[], DistributedCacheEntryOptions] | None = None,
+        hide_errors: bool | None = None,
+        consider_uow: bool = False,
+    ) -> _T | None: ...
+
+    async def get_or_add_many(
+        self,
+        keys: Iterable[str],
+        factory: Callable[[list[str]], Awaitable[Iterable[tuple[str, _T]]]],
+        *,
+        options_factory: Callable[[], DistributedCacheEntryOptions] | None = None,
+        hide_errors: bool | None = None,
+        consider_uow: bool = False,
+    ) -> list[tuple[str, _T | None]]: ...
+
+    async def set(
+        self,
+        key: str,
+        value: _T,
+        *,
+        options: DistributedCacheEntryOptions | None = None,
+        hide_errors: bool | None = None,
+        consider_uow: bool = False,
+    ) -> None: ...
+
+    async def set_many(
+        self,
+        items: Iterable[tuple[str, _T]],
+        *,
+        options: DistributedCacheEntryOptions | None = None,
+        hide_errors: bool | None = None,
+        consider_uow: bool = False,
+    ) -> None: ...
+
+    async def remove(
+        self, key: str, *, hide_errors: bool | None = None, consider_uow: bool = False
+    ) -> None: ...
+
+    async def remove_many(
+        self, keys: Iterable[str], *, hide_errors: bool | None = None, consider_uow: bool = False
+    ) -> None: ...
+
+    async def refresh(self, key: str, *, hide_errors: bool | None = None) -> None: ...
+
+    async def refresh_many(
+        self, keys: Iterable[str], *, hide_errors: bool | None = None
+    ) -> None: ...

python_ddd_framework/caching/errors.py

@@ -5,13 +5,6 @@ from __future__ import annotations
 from ..errors.base import FrameworkError
 
 
-class CacheDefinitionError(FrameworkError):
-    def __init__(self, *, cache: str, reason: str) -> None:
-        self.cache = cache
-        self.reason = reason
-        super().__init__(f"Invalid cache {cache!r}: {reason}")
-
-
 class DistributedCacheError(FrameworkError):
     def __init__(self, *, operation: str, cache: str, error_type: str) -> None:
         self.operation = operation

python_ddd_framework/caching/module.py

@@ -0,0 +1,18 @@
+"""缓存默认选项与具体 UoW 延迟写生命周期的组装 owner。"""
+
+from ..lifecycle import ConfigureContext
+from ..modularity import AppModule
+from ..unit_of_work.lifecycle import UnitOfWorkLifecycleFactory
+from ..unit_of_work.module import UnitOfWorkModule
+from .options import DistributedCacheOptions
+from .unit_of_work import _CacheLifecycleFactory
+
+
+class CachingModule(AppModule):
+    dependencies = (UnitOfWorkModule,)
+
+    def configure(self, context: ConfigureContext) -> None:
+        context.configure.default(DistributedCacheOptions, section="caching")
+        context.services.add_singleton(
+            UnitOfWorkLifecycleFactory, _CacheLifecycleFactory, multi=True
+        )

python_ddd_framework/caching/naming.py

@@ -0,0 +1,29 @@
+"""值类型拥有缓存名称；Provider 复用此元数据，不逐类型注册。"""
+
+from collections.abc import Callable
+from typing import TypeVar, get_origin
+
+_T = TypeVar("_T")
+_CACHE_NAME = "__distributed_cache_name__"
+
+
+def cache_name(name: str) -> Callable[[type[_T]], type[_T]]:
+    if not name or any(not (character.isalnum() or character in "._-") for character in name):
+        raise ValueError("cache name must be a stable identifier")
+
+    def decorate(value_type: type[_T]) -> type[_T]:
+        setattr(value_type, _CACHE_NAME, name)
+        return value_type
+
+    return decorate
+
+
+def _cache_name(value_type: type[object]) -> str:
+    if get_origin(value_type) is not None:
+        return str(value_type)
+    name = value_type.__dict__.get(_CACHE_NAME)
+    if name is None:
+        return f"{value_type.__module__}.{value_type.__qualname__}"
+    if not isinstance(name, str):
+        raise TypeError("cache name metadata must be a string")
+    return name

python_ddd_framework/caching/options.py

@@ -0,0 +1,38 @@
+"""全局默认与调用级完整对象覆盖，不建立按缓存类型的配置表。"""
+
+from datetime import datetime, timedelta
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from ..options import BaseOptions
+
+
+class DistributedCacheEntryOptions(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid", validate_default=True)
+
+    absolute_expiration: datetime | None = None
+    absolute_expiration_relative_to_now: timedelta | None = None
+    sliding_expiration: timedelta | None = None
+
+    @field_validator("absolute_expiration")
+    @classmethod
+    def _aware(cls, value: datetime | None) -> datetime | None:
+        if value is not None and value.utcoffset() is None:
+            raise ValueError("absolute_expiration must include a timezone")
+        return value
+
+    @field_validator("absolute_expiration_relative_to_now", "sliding_expiration")
+    @classmethod
+    def _positive(cls, value: timedelta | None) -> timedelta | None:
+        if value is not None and not 0 < value.total_seconds() <= 2_147_483_647:
+            raise ValueError("expiration must be positive and within the Redis range")
+        return value
+
+
+class DistributedCacheOptions(BaseOptions):
+    hide_errors: bool = True
+    default_entry_options: DistributedCacheEntryOptions = Field(
+        default_factory=lambda: DistributedCacheEntryOptions(
+            sliding_expiration=timedelta(minutes=20)
+        )
+    )

python_ddd_framework/caching/unit_of_work.py

@@ -0,0 +1,46 @@
+"""延迟写快照归具体 UoW；未完成 owner 的生命周期状态随资源退出丢弃。"""
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+
+from dishka import AsyncContainer
+
+from ..invocation import ApplicationInvocationContext
+from ..unit_of_work import UnitOfWork
+
+
+@dataclass
+class _CachePending:
+    writes: dict[str, tuple[bytes | None, Callable[[], Awaitable[None]]]] = field(
+        default_factory=dict
+    )
+
+    async def before_commit(self) -> None:
+        pass
+
+    async def after_commit(self) -> None:
+        failures: list[Exception] = []
+        try:
+            for _, apply in self.writes.values():
+                try:
+                    await apply()
+                except Exception as error:
+                    failures.append(error)
+        finally:
+            self.writes.clear()
+        if failures:
+            raise ExceptionGroup("Committed cache writes failed", failures)
+
+
+class _CacheLifecycleFactory:
+    def create(
+        self, container: AsyncContainer, context: ApplicationInvocationContext
+    ) -> _CachePending:
+        return _CachePending()
+
+
+def _pending(work: UnitOfWork) -> _CachePending:
+    for lifecycle in work._lifecycles:
+        if isinstance(lifecycle, _CachePending):
+            return lifecycle
+    raise RuntimeError("Caching lifecycle is not configured for this UnitOfWork")

python_ddd_framework/cli/__init__.py

@@ -6,6 +6,7 @@ import argparse
 import asyncio
 import os
 import subprocess
+import sys
 from collections.abc import Sequence
 from enum import Enum
 from pathlib import Path
@@ -30,12 +31,15 @@ def _parser() -> argparse.ArgumentParser:
     new.add_argument("name")
     new.add_argument("--framework-wheel", type=Path, help="Validate with a local framework wheel")
     new.add_argument("--dry-run", action="store_true")
+    new.add_argument("--python", help="Portable target version, e.g. 3.12 or 3.12.13")
+    new.add_argument("--no-sync", action="store_true", help="Generate files without an environment")
     add = commands.add_parser(
         _Command.ADD.value, help="Add a business module to the current project"
     ).add_subparsers(dest="kind", required=True)
     module = add.add_parser("module", help="Generate and register a business module")
     module.add_argument("name")
     module.add_argument("--dry-run", action="store_true")
+    module.add_argument("--template", choices=("basic", "ddd"), default="ddd")
     dev = commands.add_parser(_Command.DEV.value, help="Run the development web server")
     dev.add_argument("--host", default="127.0.0.1")
     dev.add_argument("--port", type=int, default=8000)
@@ -58,11 +62,24 @@ def _parser() -> argparse.ArgumentParser:
 
 def main(argv: Sequence[str] | None = None) -> int:
     parser = _parser()
-    args = parser.parse_args(argv)
-    if args.command is None:
-        parser.print_help()
-        return 0
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    previous_bytecode = sys.dont_write_bytecode
+    if "--dry-run" in arguments:
+        # 已处于后端环境时也不让 Host 导入在消费者源码目录留下 pycache。
+        sys.dont_write_bytecode = True
     try:
+        if arguments and arguments[0] in {
+            item.value for item in _Command if item is not _Command.NEW
+        }:
+            from .project import Project
+
+            result = Project.current().dispatch(arguments)
+            if result is not None:
+                return result
+        args = parser.parse_args(arguments)
+        if args.command is None:
+            parser.print_help()
+            return 0
         return _execute(args)
     except CommandError as error:
         parser.exit(2, f"pddd: {error}\n")
@@ -70,6 +87,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         parser.exit(
             error.returncode, "pddd: external command failed; diagnostic files were retained\n"
         )
+    finally:
+        sys.dont_write_bytecode = previous_bytecode
 
 
 def _execute(args: argparse.Namespace) -> int:
@@ -84,9 +103,15 @@ def _execute(args: argparse.Namespace) -> int:
                 "Install python-ddd-framework[developer-kit] to use generation commands"
             ) from None
         if command is _Command.NEW:
-            new_project(args.name, args.framework_wheel, args.dry_run)
+            new_project(
+                args.name,
+                args.framework_wheel,
+                args.dry_run,
+                python=args.python,
+                no_sync=args.no_sync,
+            )
         else:
-            add_module(args.name, args.dry_run)
+            add_module(args.name, args.dry_run, template=args.template)
     else:
         from .runtime import database, development_server
 

python_ddd_framework/cli/project.py

@@ -3,7 +3,11 @@
 from __future__ import annotations
 
 import importlib.metadata as metadata
+import os
+import subprocess
+import sys
 import tomllib
+from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -33,12 +37,53 @@ class Project:
 
     @classmethod
     def current(cls) -> Project:
-        root = Path.cwd().resolve()
-        project = read_project(root / "pyproject.toml").get("project", {})
-        name = project.get("name") if isinstance(project, dict) else None
-        if not isinstance(name, str) or not name:
-            raise CommandError("Current pyproject.toml must declare project.name")
-        return cls(root, name)
+        current = Path.cwd().resolve()
+        # 标准 Host entry point 标识所属后端；无 Host 的嵌套 Python 项目不拥有 pddd 命令。
+        for parent in (current, *current.parents):
+            for root in (parent / "backend", parent):
+                path = root / "pyproject.toml"
+                if not path.is_file():
+                    continue
+                project = read_project(path).get("project", {})
+                if not isinstance(project, dict):
+                    raise CommandError("Project metadata must declare project.name")
+                hosts = project.get("entry-points", {}).get(HOST_ENTRY_POINT_GROUP)
+                if hosts is None:
+                    continue
+                name = project.get("name")
+                if not isinstance(name, str) or not name:
+                    raise CommandError("Project metadata must declare project.name")
+                return cls(root, name)
+        raise CommandError("Cannot find backend project metadata with framework Host entry points")
+
+    def dispatch(self, argv: Sequence[str]) -> int | None:
+        """先交给所属环境中的 CLI，再解释命令，避免全局工具版本劫持项目。"""
+        environment = self.root / ".venv"
+        if Path(sys.prefix).resolve() == environment.resolve():
+            os.chdir(self.root)
+            return None
+        if not (environment / "pyvenv.cfg").is_file():
+            raise CommandError(f'Run uv sync --project "{self.root}" before project commands')
+        return subprocess.run(
+            [
+                "uv",
+                "run",
+                "--project",
+                str(self.root),
+                "--directory",
+                str(self.root),
+                "--no-sync",
+                "python",
+                "-I",
+                "-B",
+                "-c",
+                "from python_ddd_framework.cli import main; raise SystemExit(main())",
+                *argv,
+            ],
+            cwd=self.root,
+            env=project_environment(),
+            check=False,
+        ).returncode
 
     def host(self, name: str) -> metadata.EntryPoint:
         try:
@@ -67,3 +112,20 @@ class Project:
         if len(matches) != 1:
             raise CommandError(f"Module alias {name!r} must select exactly one live Module")
         return live[matches.pop()]
+
+
+def project_environment() -> dict[str, str]:
+    # 父进程可能来自 ROS、uv tool 或另一个项目；后端环境由本项目声明和 uv 选择。
+    environment = dict(os.environ)
+    for key in (
+        "VIRTUAL_ENV",
+        "PYTHONPATH",
+        "PYTHONHOME",
+        "UV_PROJECT_ENVIRONMENT",
+        "UV_PROJECT",
+        "UV_WORKING_DIR",
+        "UV_WORKING_DIRECTORY",
+        "UV_PYTHON",
+    ):
+        environment.pop(key, None)
+    return environment

python_ddd_framework/cli/runtime.py

@@ -11,7 +11,7 @@ from .project import Project
 
 async def database(operation: str, environment: str, module: str) -> None:
     from ..application import Application
-    from ..application_services.seeding import DataSeeder
+    from ..seeding import DataSeeder
     from ..sqlalchemy import SqlAlchemyMigrator
 
     project = Project.current()

python_ddd_framework/developer_kit/generation.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast
+import asyncio
 import importlib.metadata as metadata
 import importlib.resources as resources
 import inspect
@@ -15,7 +16,7 @@ import shutil
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 # 官方库未发布 typing marker；仅在第三方导入边界忽略缺失的类型信息。
 from cookiecutter.main import cookiecutter  # type: ignore[import-untyped]
@@ -23,7 +24,7 @@ from cookiecutter.main import cookiecutter  # type: ignore[import-untyped]
 from ..application import Application
 from ..cli import ENVIRONMENT_VARIABLE
 from ..cli.errors import CommandError
-from ..cli.project import Project, read_project
+from ..cli.project import Project, project_environment, read_project
 from .project_metadata import add_module_metadata
 from .source import framework_source
 from .wiring import add_dependency
@@ -79,8 +80,30 @@ def _validate(root: Path) -> None:
             read_project(path)
 
 
-def new_project(name: str, wheel: Path | None, dry_run: bool) -> None:
+def _python_version(value: str | None) -> tuple[str, str]:
+    version = value or platform.python_version()
+    match = re.fullmatch(r"(\d+\.\d+)(?:\.\d+)?", version)
+    distribution = metadata.distribution("python-ddd-framework")
+    supported = {
+        classifier.removeprefix("Programming Language :: Python :: ")
+        for classifier in distribution.metadata.get_all("Classifier", [])
+        if classifier.startswith("Programming Language :: Python :: ")
+    }
+    if match is None or match[1] not in supported:
+        raise CommandError("--python must be a supported Python major.minor[.patch] version")
+    return version, "==" + version + (".*" if version.count(".") == 1 else "")
+
+
+def new_project(
+    name: str,
+    wheel: Path | None,
+    dry_run: bool,
+    *,
+    python: str | None = None,
+    no_sync: bool = False,
+) -> None:
     package, class_prefix = _name(name)
+    python_version, requires_python = _python_version(python)
     destination = Path.cwd() / name
     if destination.exists():
         raise CommandError(f"Destination already exists: {destination}")
@@ -100,7 +123,8 @@ def new_project(name: str, wheel: Path | None, dry_run: bool) -> None:
             "class_prefix": class_prefix,
             "framework_version": source.version,
             "framework_source": source.uv_source,
-            "python_version": platform.python_version(),
+            "python_version": python_version,
+            "requires_python": requires_python,
             "build_version": generator,
             "host_environment_variable": ENVIRONMENT_VARIABLE,
             "database_password": secrets.token_urlsafe(24),
@@ -109,22 +133,32 @@ def new_project(name: str, wheel: Path | None, dry_run: bool) -> None:
         },
     )
     if source.wheel is not None:
-        vendor = staged / "vendor"
+        vendor = staged / "backend" / "vendor"
         vendor.mkdir()
         shutil.copy2(source.wheel, vendor / source.wheel.name)
     # copytree 原生拒绝已存在目录；staging 跨 Windows 盘符，不能依赖目录 rename。
     shutil.copytree(staged, destination)
     print(f"Generated {destination}; staging retained at {staged}")
-    subprocess.run(["uv", "sync"], cwd=destination, check=True)
+    if not no_sync:
+        backend = destination / "backend"
+        subprocess.run(
+            ["uv", "sync", "--directory", str(backend)],
+            cwd=backend,
+            env=project_environment(),
+            check=True,
+        )
 
 
-def add_module(name: str, dry_run: bool) -> None:
+def add_module(name: str, dry_run: bool, *, template: Literal["basic", "ddd"] = "ddd") -> None:
     package, class_prefix = _name(name)
     project = Project.current()
     application = project.host("application").load()(environment="development")
     if not isinstance(application, Application):
         raise CommandError("The application entry point must return Application")
-    startup = application.modules.startup.module_type
+    try:
+        startup = application.modules.startup.module_type
+    finally:
+        asyncio.run(application.stop())
     if startup.__qualname__ != startup.__name__:
         raise CommandError("Startup Module must be a top-level class for module generation")
     source_path = Path(inspect.getfile(startup)).resolve()
@@ -138,29 +172,43 @@ def add_module(name: str, dry_run: bool) -> None:
         raise CommandError(f"Module destination already exists: {destination}")
     source = source_path.read_text(encoding="utf-8")
     updated = source
-    for layer, suffix in (
-        ("application", "ApplicationModule"),
-        ("sqlalchemy", "SqlAlchemyModule"),
-        ("http_api", "HttpApiModule"),
-    ):
-        updated = add_dependency(
-            updated, startup.__name__, f"modules.{package}.{layer}.module", class_prefix + suffix
+    entries = (
+        ((f"modules.{package}.module", class_prefix + "Module"),)
+        if template == "basic"
+        else tuple(
+            (f"modules.{package}.{layer}.module", class_prefix + suffix)
+            for layer, suffix in (
+                ("application", "ApplicationModule"),
+                ("sqlalchemy", "SqlAlchemyModule"),
+                ("http_api", "HttpApiModule"),
+            )
         )
+    )
+    for import_path, class_name in entries:
+        updated = add_dependency(updated, startup.__name__, import_path, class_name)
     metadata_path = project.root / "pyproject.toml"
     metadata_source = metadata_path.read_text(encoding="utf-8")
-    updated_metadata = add_module_metadata(metadata_source, package, class_prefix)
+    alias_path, alias_class = entries[0 if template == "basic" else 1]
+    updated_metadata = add_module_metadata(metadata_source, package, f"{alias_path}:{alias_class}")
     ast.parse(updated)
     if dry_run:
         print(
             f"Would add {destination}, wire modules into {source_path} and update {metadata_path}"
         )
         return
+    context = {"module_name": package, "class_prefix": class_prefix}
+    if template == "ddd":
+        from ..fastapi.application_services import _operation_id, _service_path
+
+        # HTTP 身份由正式约定推导；basic 不读取或生成传输层配置。
+        http_identity = type(class_prefix + "ApplicationService", (), {})
+        context.update(
+            http_service_path=_service_path("", http_identity),
+            http_operation_prefix=_operation_id(http_identity, ""),
+        )
     staged = _render(
-        "module",
-        {
-            "module_name": package,
-            "class_prefix": class_prefix,
-        },
+        "basic" if template == "basic" else "module",
+        context,
     )
     # 先验证全部新文件和接线；已有 startup 文件仅在内容仍等于读取快照时替换。
     if (
@@ -178,5 +226,10 @@ def add_module(name: str, dry_run: bool) -> None:
         pending.write(updated)
     Path(pending.name).replace(source_path)
     metadata_path.write_text(updated_metadata, encoding="utf-8")
-    subprocess.run(["uv", "sync"], cwd=project.root, check=True)
+    subprocess.run(
+        ["uv", "sync", "--directory", str(project.root)],
+        cwd=project.root,
+        env=project_environment(),
+        check=True,
+    )
     print(f"Added {package}; staging retained at {staged}")

python_ddd_framework/developer_kit/project_metadata.py

@@ -8,7 +8,7 @@ from ..cli.errors import CommandError
 from ..cli.project import MODULE_ENTRY_POINT_GROUP
 
 
-def add_module_metadata(source: str, package: str, class_prefix: str) -> str:
+def add_module_metadata(source: str, package: str, entry_point: str) -> str:
     project = tomllib.loads(source)
     backend = project.get("tool", {}).get("uv", {}).get("build-backend", {})
     names = backend.get("module-name")
@@ -32,9 +32,7 @@ def add_module_metadata(source: str, package: str, class_prefix: str) -> str:
     if package in entries:
         raise CommandError(f"Module alias already exists: {package}")
     header = f'[project.entry-points."{MODULE_ENTRY_POINT_GROUP}"]'
-    declaration = (
-        f'{package} = "modules.{package}.sqlalchemy.module:{class_prefix}SqlAlchemyModule"\n'
-    )
+    declaration = f'{package} = "{entry_point}"\n'
     if MODULE_ENTRY_POINT_GROUP in project["project"].get("entry-points", {}):
         if header not in updated:
             raise CommandError("Module entry point table must use the standard quoted group name")