simple-module-cli 0.0.27__tar.gz → 0.0.29__tar.gz

{simple_module_cli-0.0.27 → simple_module_cli-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_cli
-Version: 0.0.27
+Version: 0.0.29
 Summary: Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host.
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python

{simple_module_cli-0.0.27 → simple_module_cli-0.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_cli"
-version = "0.0.27"
+version = "0.0.29"
 description = "Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host."
 readme = "README.md"
 license = "MIT"

simple_module_cli-0.0.29/simple_module_cli/_module_build.py

@@ -0,0 +1,92 @@
+"""``smpy module build`` — bundle ``<pkg>/assets_src/`` into ``<pkg>/static/dist/``.
+
+Only for assets served via :meth:`ModuleBase.static_mounts` (vendor JS,
+widgets, images). Inertia pages do NOT need this — the consuming host's Vite
+build compiles ``pages/*.tsx`` straight from the wheel.
+
+The module repo carries no bundler of its own: we borrow the verify host's
+node toolchain (``.smpy/verify-host/client_app``) and point Vite at a
+generated lib-mode config.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import typer
+
+from simple_module_cli._module_host import ModuleInfo, ensure_verify_host, require_binary
+from simple_module_cli.case import to_pascal_case
+
+_ENTRY_CANDIDATES = ("index.ts", "index.tsx", "index.js")
+
+
+def run_build(info: ModuleInfo, *, fresh: bool = False, runner=subprocess.run) -> None:
+    assets_src = info.root / info.package_name / "assets_src"
+    entry = next((assets_src / n for n in _ENTRY_CANDIDATES if (assets_src / n).is_file()), None)
+    if entry is None:
+        typer.echo(
+            f"error: no {info.package_name}/assets_src/index.(ts|tsx|js) found. "
+            "`smpy module build` bundles static_mounts() assets only — Inertia pages "
+            "are built by the consuming host and need no bundling.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    host = ensure_verify_host(info, fresh=fresh)
+    client_app = host / "client_app"
+    npm = require_binary("npm")
+    if not (client_app / "node_modules").is_dir():
+        typer.echo("[build] npm install (first run)")
+        if runner([npm, "install"], cwd=client_app).returncode != 0:
+            typer.echo("[build] FAILED at: npm install", err=True)
+            raise typer.Exit(code=1)
+
+    out_dir = info.root / info.package_name / "static" / "dist"
+    config_path = info.root / ".smpy" / "module-build.config.mjs"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(
+        _vite_lib_config(entry, out_dir, global_name=to_pascal_case(info.package_name)),
+        encoding="utf-8",
+    )
+    typer.echo(f"[build] vite build -> {info.package_name}/static/dist")
+    npx = require_binary("npx")
+    if runner([npx, "vite", "build", "--config", str(config_path)], cwd=client_app).returncode != 0:
+        typer.echo("[build] FAILED at: vite build", err=True)
+        raise typer.Exit(code=1)
+
+    _warn_missing_force_include(info)
+    typer.echo("[build] OK")
+
+
+def _vite_lib_config(entry: Path, out_dir: Path, *, global_name: str) -> str:
+    return f"""\
+import {{ defineConfig }} from 'vite'
+
+export default defineConfig({{
+  build: {{
+    lib: {{
+      entry: {entry.as_posix()!r},
+      formats: ['iife'],
+      name: {global_name!r},
+      fileName: () => 'index.js',
+    }},
+    outDir: {out_dir.as_posix()!r},
+    emptyOutDir: true,
+  }},
+}})
+"""
+
+
+def _warn_missing_force_include(info: ModuleInfo) -> None:
+    """static/dist is gitignored — without an artifacts entry the wheel silently omits it."""
+    pyproject = (info.root / "pyproject.toml").read_text(encoding="utf-8")
+    if f"{info.package_name}/static/dist" not in pyproject:
+        typer.echo(
+            "warning: pyproject.toml does not ship "
+            f'"{info.package_name}/static/dist" — the built bundle will NOT be in the wheel. '
+            "Add under [tool.hatch.build.targets.wheel]:\n"
+            f'  artifacts = ["{info.package_name}/static/dist/"]',
+            err=True,
+        )

simple_module_cli-0.0.29/simple_module_cli/_module_host.py

@@ -0,0 +1,85 @@
+"""Shared plumbing for ``smpy module`` commands.
+
+Out-of-tree module repos have no frontend toolchain of their own — the
+commands borrow one by scaffolding a throwaway host (via the same templates
+as ``smpy create-host``) into ``.smpy/verify-host/`` and caching it there.
+"""
+
+from __future__ import annotations
+
+import shutil
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from simple_module_cli.scaffolding import create_host, resolve_framework_version
+
+VERIFY_HOST_RELPATH = Path(".smpy") / "verify-host"
+
+
+@dataclass(frozen=True)
+class ModuleInfo:
+    """Identity of the module under the cwd, read from its pyproject."""
+
+    root: Path
+    pypi_name: str  # [project].name, e.g. simple_module_my_feature
+    package_name: str  # the simple_module entry-point key, e.g. my_feature
+
+
+def read_module_info(root: Path) -> ModuleInfo:
+    pyproject = root / "pyproject.toml"
+    if not pyproject.is_file():
+        typer.echo(f"error: no pyproject.toml in {root} — run from the module repo root.", err=True)
+        raise typer.Exit(code=1)
+    data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+    entry_points = data.get("project", {}).get("entry-points", {}).get("simple_module", {})
+    if not entry_points:
+        typer.echo(
+            "error: pyproject.toml declares no [project.entry-points.simple_module] — "
+            "this does not look like a SimpleModule module.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+    return ModuleInfo(
+        root=root,
+        pypi_name=data["project"]["name"],
+        package_name=next(iter(entry_points)),
+    )
+
+
+def require_binary(name: str) -> str:
+    """Resolve ``name`` on PATH or exit with a clear message (npm on Windows is npm.cmd)."""
+    path = shutil.which(name)
+    if path is None:
+        typer.echo(f"error: '{name}' not found on PATH — install it and retry.", err=True)
+        raise typer.Exit(code=1)
+    return path
+
+
+def ensure_verify_host(info: ModuleInfo, *, fresh: bool = False) -> Path:
+    """Scaffold (or reuse) the cached verify host; return its directory."""
+    host_dir = info.root / VERIFY_HOST_RELPATH
+    if fresh and host_dir.exists():
+        shutil.rmtree(host_dir)
+    if not (host_dir / "pyproject.toml").is_file():
+        create_host(
+            host_dir,
+            name="verify_host",
+            modules=[],
+            framework_version=resolve_framework_version(),
+        )
+        _wire_module_dep(host_dir / "pyproject.toml", info.pypi_name)
+    return host_dir
+
+
+def _wire_module_dep(pyproject_path: Path, pypi_name: str) -> None:
+    """Add the module as an editable path dependency of the verify host."""
+    text = pyproject_path.read_text(encoding="utf-8")
+    # Unpinned on purpose: [tool.uv.sources] overrides it with the local path.
+    # Note: pin_framework_deps may have rewritten the array onto one line, so
+    # match the opening bracket only — TOML tolerates the injected newline.
+    text = text.replace("dependencies = [", f'dependencies = [\n    "{pypi_name}",', 1)
+    text += f'\n[tool.uv.sources]\n{pypi_name} = {{ path = "../..", editable = true }}\n'
+    pyproject_path.write_text(text, encoding="utf-8")

simple_module_cli-0.0.29/simple_module_cli/_templating.py

@@ -0,0 +1,82 @@
+"""Package-data template engine shared by the scaffolders.
+
+Extracted from :mod:`simple_module_cli.scaffolding` (which keeps the public
+``create_workspace`` / ``create_host`` / ``create_module`` entry points) so
+each file has one job: this one renders template trees, that one decides what
+to render.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import shutil
+from collections.abc import Mapping
+from pathlib import Path
+
+_TEMPLATES_PACKAGE = "simple_module_cli.templates"
+_PACKAGE_PATH_TOKEN = "__PACKAGE__"
+
+
+def _iter_template_files(template_root: Path):
+    """Yield every file under ``template_root``. Skips ``_optional/`` paths."""
+    for path in template_root.rglob("*"):
+        if not path.is_file():
+            continue
+        if "_optional" in path.relative_to(template_root).parts:
+            continue
+        yield path
+
+
+def _require_empty_dest(dest: Path, *, preserve_existing: frozenset[str] = frozenset()) -> None:
+    """Refuse a non-empty destination unless every top-level entry is allowed.
+
+    ``preserve_existing`` is matched against the *name* of each top-level entry,
+    so callers can permit common pre-existing files (``.git``, ``README.md``,
+    ...) without silently overwriting unrelated user content.
+    """
+    if dest.exists():
+        unexpected = sorted(p.name for p in dest.iterdir() if p.name not in preserve_existing)
+        if unexpected:
+            raise FileExistsError(
+                f"Destination {dest} exists and contains files that would collide "
+                f"with the scaffold: {', '.join(unexpected)}. "
+                "Move them aside or choose another path."
+            )
+    dest.mkdir(parents=True, exist_ok=True)
+
+
+def _resolve_template_root(subdir: str, override: Path | None) -> Path:
+    if override is not None:
+        return Path(override)
+    return Path(str(importlib.resources.files(_TEMPLATES_PACKAGE) / subdir))
+
+
+def _apply_template_files(
+    src_root: Path,
+    dest: Path,
+    substitutions: Mapping[str, str],
+    *,
+    path_rewrites: Mapping[str, str] | None = None,
+    preserve_existing: frozenset[str] = frozenset(),
+) -> list[Path]:
+    """Write template files into ``dest``; return paths skipped to preserve the user's copy."""
+    preserved: list[Path] = []
+    for src in _iter_template_files(src_root):
+        rel_str = str(src.relative_to(src_root))
+        for old, new in (path_rewrites or {}).items():
+            rel_str = rel_str.replace(old, new)
+        rel_str = rel_str.removesuffix(".tpl")
+        target = dest / rel_str
+        top = Path(rel_str).parts[0] if rel_str else ""
+        if top in preserve_existing and target.exists():
+            preserved.append(target)
+            continue
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if src.suffix == ".tpl":
+            text = src.read_text(encoding="utf-8")
+            for placeholder, value in substitutions.items():
+                text = text.replace(placeholder, value)
+            target.write_text(text, encoding="utf-8")
+        else:
+            shutil.copy2(src, target)
+    return preserved

{simple_module_cli-0.0.27 → simple_module_cli-0.0.29}/simple_module_cli/app_project.py

@@ -22,6 +22,7 @@ from typing import Any
 from simple_module_cli._env import set_env_key
 from simple_module_cli.case import to_kebab_case, to_pascal_case
 from simple_module_cli.catalog import CATALOG, PRESETS, expand_deps
+from simple_module_cli.docker_assets import scaffold_docker_assets
 from simple_module_cli.recipes import RECIPES, ScaffoldCtx
 from simple_module_cli.scaffolding import (
     SAFE_PRESERVED_NAMES,
@@ -141,6 +142,15 @@ def create_app_project(
     env_path = target / ".env.example"
     env_text = env_path.read_text(encoding="utf-8") if env_path.exists() else ""
     env_text = set_env_key(env_text, "SM_SECRET_KEY", _secrets.token_urlsafe(32))
+    if "users" in resolved:
+        # UsersSettings refuses its placeholder token secrets when
+        # SM_ENVIRONMENT=production — the mode the compose containers run
+        # in — so generate real ones, same as SM_SECRET_KEY above.
+        for key in (
+            "SM_USERS_RESET_PASSWORD_TOKEN_SECRET",
+            "SM_USERS_VERIFICATION_TOKEN_SECRET",
+        ):
+            env_text = set_env_key(env_text, key, _secrets.token_urlsafe(32))
     env_text = set_env_key(env_text, "SM_DATABASE_URL", _db_url(db, to_kebab_case(name), flat=flat))
     env_text = set_env_key(env_text, "SM_MULTI_TENANT", "true" if tenancy else "false")
     env_path.write_text(env_text, encoding="utf-8")
@@ -176,6 +186,8 @@ def create_app_project(
         if recipe_key is not None and recipe_key in RECIPES:
             RECIPES[recipe_key].apply(target, ctx)
 
+    scaffold_docker_assets(target, ctx, flat=flat)
+
     return host_dir, preserved
 
 
@@ -199,7 +211,7 @@ def _scaffold_sample_module(target: Path) -> None:
         sample_dest,
         name=_SAMPLE_MODULE_NAME,
         framework_version=_FRAMEWORK_VERSION,
-        include_ci=False,
+        standalone=False,
     )
     _seed_static_dist_placeholder(sample_dest / _SAMPLE_MODULE_NAME / "static" / "dist")
 

{simple_module_cli-0.0.27 → simple_module_cli-0.0.29}/simple_module_cli/cli.py

@@ -18,6 +18,7 @@ from typing import Annotated
 import typer
 
 from simple_module_cli.case import to_kebab_case
+from simple_module_cli.module_cmd import module_app
 from simple_module_cli.new import new_project
 from simple_module_cli.package_update import package_update
 from simple_module_cli.plugins import discover_and_mount
@@ -35,6 +36,7 @@ app = typer.Typer(
 app.command("new")(new_project)
 app.command("package-update")(package_update)
 app.add_typer(skills_app, name="skills")
+app.add_typer(module_app, name="module")
 
 
 @app.command("create-host")
@@ -104,10 +106,11 @@ def create_module(
     slug = to_kebab_case(name)
     package = slug.replace("-", "_")
     target = dest or Path.cwd() / f"simple_module_{package}"
-    # An in-repo module (the documented modules/* layout) gets no .github/: those
-    # nested workflows never run and publish.yml is a PyPI footgun. --standalone
-    # forces them for a module that lives in its own repo. See GH #210.
-    include_ci = standalone or not is_inside_existing_repo(target)
+    # An in-repo module (the documented modules/* layout) gets no .github/ and
+    # keeps the workspace JS configs: nested workflows never run and publish.yml
+    # is a PyPI footgun. --standalone forces the standalone layout for a module
+    # that lives in its own repo. See GH #210.
+    standalone_mode = standalone or not is_inside_existing_repo(target)
     try:
         # Pin framework deps to the installed framework version so the module
         # resolves against the app that created it (the template's >=1.0,<2.0
@@ -116,14 +119,14 @@ def create_module(
             target,
             name=name,
             framework_version=resolve_framework_version(),
-            include_ci=include_ci,
+            standalone=standalone_mode,
         )
     except FileExistsError as exc:
         typer.echo(f"ERROR: {exc}", err=True)
         raise typer.Exit(code=1) from exc
 
     typer.echo(f"Created module 'simple_module_{package}' at {target}")
-    if not include_ci:
+    if not standalone_mode:
         typer.echo(
             "Skipped .github/ workflows: this module is inside an existing repo, "
             "where nested workflows never run. Use --standalone to emit them."
@@ -132,6 +135,9 @@ def create_module(
     typer.echo(f"  cd {target}")
     typer.echo("  uv sync --extra dev")
     typer.echo("  uv run pytest")
+    typer.echo("  npm install")
+    typer.echo("  npm run typecheck")
+    typer.echo("  uv run smpy module verify")
 
 
 discover_and_mount(app)

simple_module_cli-0.0.29/simple_module_cli/docker_assets.py

@@ -0,0 +1,100 @@
+"""Default Docker assets for ``smpy new`` scaffolds.
+
+Every new app ships a container story out of the box: a multi-stage
+``docker/host.Dockerfile``, a ``docker-compose.yml`` matched to the
+scaffold's DB choice (app on a SQLite volume, or postgres + app; plus
+redis/worker/beat when ``background_tasks`` is selected), a
+``.dockerignore``, and ``docker-*`` Make targets. This runs for every
+scaffold — unlike per-module recipes — because the compose service set
+depends on the *whole* module selection, which only the scaffolder knows.
+
+worker/beat reuse the app image with a different command: the workspace
+venv already contains everything (``uv sync --all-packages``), so a
+separate worker Dockerfile would only duplicate build logic.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import shutil
+from pathlib import Path
+
+from simple_module_cli.case import to_kebab_case
+from simple_module_cli.recipes import ScaffoldCtx
+
+__all__ = ["scaffold_docker_assets"]
+
+_MAKEFILE_MARKER = "# --- docker --"
+_PG_DB_TOKEN = "{{PG_DB}}"
+_APP_EXTRA_ENV_TOKEN = "{{APP_EXTRA_ENV}}"
+
+# BackgroundTasksSettings refuses a localhost broker when
+# SM_ENVIRONMENT=production, so the app container needs the compose-network
+# broker URLs too — not just worker/beat.
+_APP_BROKER_ENV = (
+    "      SM_BG_TASKS_BROKER_URL: redis://redis:6379/0\n"
+    "      SM_BG_TASKS_RESULT_BACKEND: redis://redis:6379/1\n"
+)
+
+
+def _template_root() -> Path:
+    base = importlib.resources.files("simple_module_cli")
+    return Path(str(base / "templates" / "docker"))
+
+
+def scaffold_docker_assets(target: Path, ctx: ScaffoldCtx, *, flat: bool = False) -> None:
+    """Emit compose + Dockerfile + .dockerignore + Make targets at ``target``.
+
+    The compose file is assembled from fragments: a per-DB base (app alone
+    on SQLite, or postgres + app), per-DB worker services when
+    ``background_tasks`` is selected, and a computed ``volumes:`` block —
+    appending fragments keeps the templates plain YAML instead of merge
+    logic.
+    """
+    templates = _template_root()
+    compose_dest = target / "docker-compose.yml"
+    dockerfile_dest = target / "docker" / "host.Dockerfile"
+    for path in (compose_dest, dockerfile_dest):
+        if path.exists():
+            raise FileExistsError(
+                f"{path} already exists — refusing to clobber. "
+                "Remove the file or run `smpy new` against an empty directory."
+            )
+
+    dockerfile_dest.parent.mkdir(parents=True, exist_ok=True)
+    src_name = "host-flat.Dockerfile" if flat else "host.Dockerfile"
+    shutil.copy2(templates / src_name, dockerfile_dest)
+
+    # The compose stack must match the scaffold's DB choice: a migration
+    # history is dialect-frozen at autogenerate time (e.g. sa.false()
+    # compiles to DEFAULT 0 on SQLite, which Postgres rejects), so pointing
+    # a sqlite-scaffolded app at a Postgres container fails on first boot.
+    db = "postgres" if ctx.db == "postgres" else "sqlite"
+    pg_db = to_kebab_case(ctx.name)
+    with_tasks = "background_tasks" in ctx.selected
+    compose = (
+        _read(templates / f"compose-base-{db}.yml.tpl")
+        .replace(_PG_DB_TOKEN, pg_db)
+        .replace(_APP_EXTRA_ENV_TOKEN, _APP_BROKER_ENV if with_tasks else "")
+    )
+    volumes = ["pgdata"] if db == "postgres" else ["appdata"]
+    if with_tasks:
+        compose += _read(templates / f"compose-tasks-{db}.yml.tpl").replace(_PG_DB_TOKEN, pg_db)
+        volumes.append("redisdata")
+    compose += "\nvolumes:\n" + "".join(f"  {name}:\n" for name in volumes)
+    compose_dest.write_text(compose, encoding="utf-8")
+
+    ignore_dest = target / ".dockerignore"
+    if not ignore_dest.exists():
+        shutil.copy2(templates / "dockerignore", ignore_dest)
+
+    makefile_path = target / "Makefile"
+    existing = makefile_path.read_text(encoding="utf-8") if makefile_path.exists() else ""
+    if _MAKEFILE_MARKER not in existing:
+        snippet = _read(templates / "Makefile.snippet")
+        sep = "" if existing.endswith("\n") or not existing else "\n"
+        makefile_path.write_text(existing + sep + snippet, encoding="utf-8")
+
+
+def _read(path: Path) -> str:
+    return path.read_text(encoding="utf-8")

simple_module_cli-0.0.29/simple_module_cli/module_cmd.py

@@ -0,0 +1,82 @@
+"""``smpy module`` — commands for developing a module out-of-tree (own repo)."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import typer
+
+from simple_module_cli._module_host import (
+    ModuleInfo,
+    ensure_verify_host,
+    read_module_info,
+    require_binary,
+)
+
+module_app = typer.Typer(help="Develop a SimpleModule module outside a host repo.")
+
+
+def run_verify(info: ModuleInfo, *, fresh: bool = False, runner=subprocess.run) -> None:
+    """Prove the module's TSX + CSS compile against a real scaffolded host.
+
+    Output streams straight to the terminal (CI logs want the full Vite/tsc
+    output); on failure we name the step and exit 1.
+    """
+    host = ensure_verify_host(info, fresh=fresh)
+    client_app = host / "client_app"
+    uv, npm = require_binary("uv"), require_binary("npm")
+    steps: tuple[tuple[str, list[str], Path], ...] = (
+        # The module's own node_modules first: esbuild resolves the module
+        # tsconfig's `extends` (@simple-module-py/tsconfig) from there when
+        # compiling pages out of the editable checkout.
+        *(
+            (("npm install (module)", [npm, "install"], info.root),)
+            if (info.root / "package.json").is_file()
+            else ()
+        ),
+        ("uv sync", [uv, "sync"], host),
+        ("npm install", [npm, "install"], client_app),
+        (
+            "gen-pages",
+            [
+                uv,
+                "run",
+                "python",
+                "-m",
+                "simple_module_hosting",
+                "gen-pages",
+                "--host-dir=client_app",
+            ],
+            host,
+        ),
+        ("frontend build (tsc + vite)", [npm, "run", "build"], client_app),
+    )
+    for label, cmd, cwd in steps:
+        typer.echo(f"[verify] {label}")
+        if runner(cmd, cwd=cwd).returncode != 0:
+            typer.echo(f"[verify] FAILED at: {label}", err=True)
+            raise typer.Exit(code=1)
+    typer.echo("[verify] OK — module frontend builds against a scaffolded host")
+
+
+@module_app.command("verify")
+def verify_command(
+    fresh: bool = typer.Option(
+        False, "--fresh", help="Rebuild the cached .smpy/verify-host from scratch."
+    ),
+) -> None:
+    """Build this module's frontend inside a throwaway scaffolded host."""
+    run_verify(read_module_info(Path.cwd()), fresh=fresh)
+
+
+@module_app.command("build")
+def build_command(
+    fresh: bool = typer.Option(
+        False, "--fresh", help="Rebuild the cached .smpy/verify-host from scratch."
+    ),
+) -> None:
+    """Bundle <pkg>/assets_src/ into <pkg>/static/dist/ for static_mounts()."""
+    from simple_module_cli._module_build import run_build
+
+    run_build(read_module_info(Path.cwd()), fresh=fresh)

{simple_module_cli-0.0.27 → simple_module_cli-0.0.29}/simple_module_cli/new.py

@@ -141,6 +141,7 @@ def new_project(
         typer.echo('  make migration msg="initial schema"')
         typer.echo("  make migrate")
         typer.echo("  make dev")
+        typer.echo("  make docker-up   # or run the full stack in containers")
         if "background_tasks" in resolved:
             typer.echo("  docker compose up -d redis worker beat   # background jobs")
         return
@@ -168,6 +169,7 @@ def new_project(
     # errors once a second module ships its own migration branch label.
     subprocess.run([*_ALEMBIC, "upgrade", "heads"], cwd=host_dir, check=False)
     typer.echo("\nSetup complete. Run `make dev` in the new directory.")
+    typer.echo("To run the full stack in containers instead: make docker-up")
     if "background_tasks" in resolved:
         typer.echo("For background jobs, also run: docker compose up -d redis worker beat")
 

{simple_module_cli-0.0.27 → simple_module_cli-0.0.29}/simple_module_cli/recipes.py

@@ -49,37 +49,26 @@ def _optional_template_root(name: str) -> Path:
 
 
 class BackgroundTasksRecipe:
-    """Lays down run_worker.py + compose + Dockerfiles + Make targets."""
+    """Lays down run_worker.py + broker env keys + Make targets.
+
+    The compose services (redis/worker/beat) and the shared app image come
+    from the default Docker assets every scaffold gets — see
+    :mod:`simple_module_cli.docker_assets`.
+    """
 
     def apply(self, target: Path, ctx: ScaffoldCtx) -> None:
         templates = _optional_template_root("background_tasks")
 
         run_worker_dest = target / "scripts" / "run_worker.py"
-        compose_dest = target / "docker-compose.yml"
-        host_dockerfile_dest = target / "docker" / "host.Dockerfile"
-        worker_dockerfile_dest = target / "docker" / "worker.Dockerfile"
-
-        for path in (
-            run_worker_dest,
-            compose_dest,
-            host_dockerfile_dest,
-            worker_dockerfile_dest,
-        ):
-            if path.exists():
-                raise FileExistsError(
-                    f"{path} already exists — refusing to clobber. "
-                    "Remove the file or run `smpy new` against an empty directory."
-                )
+        if run_worker_dest.exists():
+            raise FileExistsError(
+                f"{run_worker_dest} already exists — refusing to clobber. "
+                "Remove the file or run `smpy new` against an empty directory."
+            )
 
         run_worker_dest.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy2(templates / "run_worker.py", run_worker_dest)
 
-        shutil.copy2(templates / "docker-compose.yml", compose_dest)
-
-        host_dockerfile_dest.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(templates / "host.Dockerfile", host_dockerfile_dest)
-        shutil.copy2(templates / "worker.Dockerfile", worker_dockerfile_dest)
-
         env_path = target / ".env.example"
         env_text = env_path.read_text(encoding="utf-8") if env_path.exists() else ""
         env_path.write_text(