csrd-utils 0.3.2__tar.gz → 0.3.5__tar.gz

csrd_utils-0.3.5/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: csrd-utils
+Version: 0.3.5
+Summary: CLI utilities for csrd service generation and feature augmentation
+Project-URL: Repository, https://github.com/csrd-api/fastapi-common
+Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/utils
+Project-URL: Changelog, https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: cookiecutter<3,>=2.6
+Requires-Dist: pyyaml<7,>=6
+Description-Content-Type: text/markdown
+
+# csrd-utils
+
+CLI and runtime helpers for generating csrd services and augmenting existing services with optional features.
+
+## Install
+
+```bash
+pip install "csrd-utils @ git+https://github.com/csrd-api/fastapi-common.git#subdirectory=packages/utils"
+```
+
+## CLI
+
+```bash
+csrd --help
+csrd --version
+csrd new service                                  # interactive prompts
+csrd new service --interactive --name items       # pre-fills name prompt with 'items'
+csrd new service --name inventory --no-interactive --output .
+csrd feature list
+csrd feature plan workers --service .
+csrd feature plan workers --service . --json
+csrd feature add workers --service .
+csrd doctor --service .
+```
+
+`feature plan --json` is useful for CI or tooling wrappers.
+
+### Interactive generation behavior
+
+- `csrd new service` runs interactive prompts by default.
+- Passing `--name <value>` in interactive mode uses that value as the name prompt default.
+- You can still overwrite the default by entering a different value at the prompt.
+- Use `--no-interactive` for fully flag-driven generation.
+
+## Typical workflow
+
+```bash
+# 0) Generate a new service from bundled template
+csrd new service --name inventory --output . --database postgres --workers
+
+# 1) Verify service compatibility
+csrd doctor --service ./inventory
+
+# 2) Inspect available bundled features
+csrd feature list
+
+# 3) Dry-run a feature
+csrd feature plan workers --service ./inventory
+
+# 4) Apply feature files/merges
+csrd feature add workers --service ./inventory
+```
+
+## Bundled assets
+
+- `features/workers/` feature manifests and fragments
+- `templates/cookiecutter-service/` template starter
+
+## Python API
+
+```python
+from pathlib import Path
+from csrd_utils import ServiceAugmentor
+from csrd_utils.resources import features_path
+
+with features_path() as feature_lib:
+    augmentor = ServiceAugmentor(Path("."), feature_lib)
+    ok, changes = augmentor.add_feature("workers", plan=True)
+```
+
+## Documentation
+
+- `docs/CLI_REFERENCE.md` - full command/flag reference
+- `docs/FEATURES.md` - bundled feature catalog and behavior
+- `docs/AGENT_SMOKE_TESTS.md` - copy/paste validation flow for clean workspaces
+- `docs/COMMAND_MATRIX.yaml` - machine-readable command matrix for automation
+- `AGENTS.md` - package-local rules for autonomous agents
+
+## CLI-only agent mode
+
+If an agent can only see the installed CLI (not source files), use this exploration sequence:
+
+```bash
+csrd --help
+csrd new --help
+csrd feature --help
+csrd doctor --help
+csrd feature list
+```
+
+Then run a clean smoke flow:
+
+```bash
+mkdir -p /tmp/csrd-smoke
+cd /tmp/csrd-smoke
+csrd new service --name demo-svc --output . --no-interactive
+cd demo-svc
+csrd doctor
+csrd feature plan workers
+csrd feature add workers
+```

csrd_utils-0.3.5/README.md

@@ -0,0 +1,101 @@
+# csrd-utils
+
+CLI and runtime helpers for generating csrd services and augmenting existing services with optional features.
+
+## Install
+
+```bash
+pip install "csrd-utils @ git+https://github.com/csrd-api/fastapi-common.git#subdirectory=packages/utils"
+```
+
+## CLI
+
+```bash
+csrd --help
+csrd --version
+csrd new service                                  # interactive prompts
+csrd new service --interactive --name items       # pre-fills name prompt with 'items'
+csrd new service --name inventory --no-interactive --output .
+csrd feature list
+csrd feature plan workers --service .
+csrd feature plan workers --service . --json
+csrd feature add workers --service .
+csrd doctor --service .
+```
+
+`feature plan --json` is useful for CI or tooling wrappers.
+
+### Interactive generation behavior
+
+- `csrd new service` runs interactive prompts by default.
+- Passing `--name <value>` in interactive mode uses that value as the name prompt default.
+- You can still overwrite the default by entering a different value at the prompt.
+- Use `--no-interactive` for fully flag-driven generation.
+
+## Typical workflow
+
+```bash
+# 0) Generate a new service from bundled template
+csrd new service --name inventory --output . --database postgres --workers
+
+# 1) Verify service compatibility
+csrd doctor --service ./inventory
+
+# 2) Inspect available bundled features
+csrd feature list
+
+# 3) Dry-run a feature
+csrd feature plan workers --service ./inventory
+
+# 4) Apply feature files/merges
+csrd feature add workers --service ./inventory
+```
+
+## Bundled assets
+
+- `features/workers/` feature manifests and fragments
+- `templates/cookiecutter-service/` template starter
+
+## Python API
+
+```python
+from pathlib import Path
+from csrd_utils import ServiceAugmentor
+from csrd_utils.resources import features_path
+
+with features_path() as feature_lib:
+    augmentor = ServiceAugmentor(Path("."), feature_lib)
+    ok, changes = augmentor.add_feature("workers", plan=True)
+```
+
+## Documentation
+
+- `docs/CLI_REFERENCE.md` - full command/flag reference
+- `docs/FEATURES.md` - bundled feature catalog and behavior
+- `docs/AGENT_SMOKE_TESTS.md` - copy/paste validation flow for clean workspaces
+- `docs/COMMAND_MATRIX.yaml` - machine-readable command matrix for automation
+- `AGENTS.md` - package-local rules for autonomous agents
+
+## CLI-only agent mode
+
+If an agent can only see the installed CLI (not source files), use this exploration sequence:
+
+```bash
+csrd --help
+csrd new --help
+csrd feature --help
+csrd doctor --help
+csrd feature list
+```
+
+Then run a clean smoke flow:
+
+```bash
+mkdir -p /tmp/csrd-smoke
+cd /tmp/csrd-smoke
+csrd new service --name demo-svc --output . --no-interactive
+cd demo-svc
+csrd doctor
+csrd feature plan workers
+csrd feature add workers
+```

{csrd_utils-0.3.2 → csrd_utils-0.3.5}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "csrd-utils"
-version = "0.3.2"
+version = "0.3.5"
 description = "CLI utilities for csrd service generation and feature augmentation"
 license = { text = "MIT" }
 requires-python = ">=3.12"
 dependencies = [
+    "cookiecutter>=2.6,<3",
     "PyYAML>=6,<7",
 ]
 readme = "README.md"

csrd_utils-0.3.5/src/csrd_utils/__init__.py

@@ -0,0 +1,7 @@
+"""csrd-utils: template and feature tooling for csrd services."""
+
+from .augmentor import ServiceAugmentor
+from .doctor import run_doctor
+from .generator import generate_service
+
+__all__ = ["ServiceAugmentor", "generate_service", "run_doctor"]

csrd_utils-0.3.5/src/csrd_utils/__main__.py

@@ -0,0 +1,337 @@
+"""Command-line interface for csrd-utils."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from importlib.metadata import version
+from pathlib import Path
+from typing import TypedDict
+
+from .augmentor import ServiceAugmentor
+from .doctor import run_doctor
+from .generator import generate_service
+from .resources import features_path
+
+
+class GenerateServiceArgs(TypedDict):
+    name: str
+    output_dir: Path
+    description: str
+    port: int
+    model_name: str
+    model_name_plural: str
+    has_database: bool
+    database: str
+    has_delegates: bool
+    upstreams: str
+    has_workers: bool
+    broker: str
+    has_caching: bool
+    cache_backend: str
+    has_structured_logging: bool
+    overwrite_if_exists: bool
+
+
+def _prompt_text(label: str, default: str) -> str:
+    value = input(f"{label} [{default}]: ").strip()
+    return value or default
+
+
+def _prompt_bool(label: str, default: bool) -> bool:
+    suffix = "Y/n" if default else "y/N"
+    value = input(f"{label} ({suffix}): ").strip().lower()
+    if not value:
+        return default
+    return value in {"y", "yes", "true", "1"}
+
+
+def _prompt_choice(label: str, choices: list[str], default: str) -> str:
+    rendered = ", ".join(choices)
+    while True:
+        value = input(f"{label} [{default}] ({rendered}): ").strip().lower()
+        if not value:
+            return default
+        if value in choices:
+            return value
+        print(f"ERROR: Invalid choice '{value}'. Expected one of: {rendered}")
+
+
+def _prompt_int(label: str, default: int) -> int:
+    while True:
+        value = input(f"{label} [{default}]: ").strip()
+        if not value:
+            return default
+        try:
+            return int(value)
+        except ValueError:
+            print("ERROR: Enter a valid integer")
+
+
+def _collect_new_service_config(args: argparse.Namespace) -> GenerateServiceArgs:
+    explicit_interactive = getattr(args, "interactive", None)
+    interactive = (
+        bool(explicit_interactive) if explicit_interactive is not None else args.name is None
+    )
+
+    # Non-interactive mode keeps current flag-driven behavior.
+    if not interactive:
+        has_database = args.database != "none"
+        selected_database = "sqlite" if not has_database else args.database
+        return GenerateServiceArgs(
+            {
+                "name": args.name,
+                "output_dir": args.output,
+                "description": args.description,
+                "port": args.port,
+                "model_name": args.model_name,
+                "model_name_plural": args.model_name_plural,
+                "has_database": has_database,
+                "database": selected_database,
+                "has_delegates": args.delegates,
+                "upstreams": args.upstreams,
+                "has_workers": args.workers,
+                "broker": args.broker,
+                "has_caching": args.caching,
+                "cache_backend": args.cache_backend,
+                "has_structured_logging": args.structured_logging,
+                "overwrite_if_exists": args.force,
+            }
+        )
+
+    print("Interactive mode: press Enter to accept defaults.")
+
+    name = _prompt_text("Service name", args.name or "my-service")
+    output_dir = Path(_prompt_text("Output directory", str(args.output)))
+    description = _prompt_text("Service description", args.description)
+    port = _prompt_int("HTTP port", args.port)
+    model_name = _prompt_text("Model name", args.model_name)
+
+    plural_default = args.model_name_plural
+    if plural_default == "items" and model_name != "Item":
+        plural_default = f"{model_name.lower()}s"
+    model_name_plural = _prompt_text("Model name plural", plural_default)
+
+    database = _prompt_choice("Database", ["sqlite", "maria", "postgres", "none"], args.database)
+    has_database = database != "none"
+    selected_database = "sqlite" if not has_database else database
+
+    has_delegates = _prompt_bool("Enable delegates", args.delegates)
+    upstreams_default = args.upstreams
+    if has_delegates and not upstreams_default:
+        upstreams_default = "http://service-a:8080"
+    upstreams = (
+        _prompt_text("Delegates upstreams (comma-separated)", upstreams_default)
+        if has_delegates
+        else ""
+    )
+
+    has_workers = _prompt_bool("Enable workers", args.workers)
+    broker = (
+        _prompt_choice("Worker broker", ["redis", "rabbitmq"], args.broker)
+        if has_workers
+        else args.broker
+    )
+
+    has_caching = _prompt_bool("Enable caching", args.caching)
+    cache_backend = (
+        _prompt_choice("Cache backend", ["redis"], args.cache_backend)
+        if has_caching
+        else args.cache_backend
+    )
+
+    has_structured_logging = _prompt_bool("Enable structured logging", args.structured_logging)
+    overwrite_if_exists = _prompt_bool("Overwrite if target exists", args.force)
+
+    return GenerateServiceArgs(
+        {
+            "name": name,
+            "output_dir": output_dir,
+            "description": description,
+            "port": port,
+            "model_name": model_name,
+            "model_name_plural": model_name_plural,
+            "has_database": has_database,
+            "database": selected_database,
+            "has_delegates": has_delegates,
+            "upstreams": upstreams,
+            "has_workers": has_workers,
+            "broker": broker,
+            "has_caching": has_caching,
+            "cache_backend": cache_backend,
+            "has_structured_logging": has_structured_logging,
+            "overwrite_if_exists": overwrite_if_exists,
+        }
+    )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="csrd", description="csrd utilities")
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"csrd-utils {version('csrd-utils')}",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    feature = sub.add_parser("feature", help="Feature operations")
+    feature_sub = feature.add_subparsers(dest="feature_command")
+
+    list_cmd = feature_sub.add_parser("list", help="List bundled features")
+    list_cmd.set_defaults(plan=False)
+
+    for name, plan in (("add", False), ("plan", True)):
+        cmd = feature_sub.add_parser(name, help=f"{name} feature")
+        cmd.add_argument("feature", help="Feature name, e.g. workers")
+        cmd.add_argument("--service", type=Path, default=Path.cwd(), help="Service root path")
+        if name == "plan":
+            cmd.add_argument("--json", action="store_true", help="Print plan as JSON")
+        cmd.set_defaults(plan=plan)
+
+    doctor = sub.add_parser("doctor", help="Validate service compatibility")
+    doctor.add_argument("--service", type=Path, default=Path.cwd(), help="Service root path")
+    doctor.add_argument("--json", action="store_true", help="Print doctor report as JSON")
+
+    new = sub.add_parser("new", help="Generate new assets")
+    new_sub = new.add_subparsers(dest="new_command")
+    service = new_sub.add_parser("service", help="Generate a service from bundled template")
+    service.add_argument("--name", help="Service name")
+    service.add_argument("--output", type=Path, default=Path.cwd(), help="Output directory")
+    service.add_argument(
+        "--description",
+        default="A microservice using the csrd library stack",
+        help="Service description",
+    )
+    service.add_argument("--port", type=int, default=8080, help="HTTP service port")
+    service.add_argument("--model-name", default="Item", help="Primary model name")
+    service.add_argument("--model-name-plural", default="items", help="Plural model name")
+    service.add_argument(
+        "--database", choices=["sqlite", "maria", "postgres", "none"], default="sqlite"
+    )
+    service.add_argument("--delegates", action="store_true", help="Enable delegates")
+    service.add_argument("--upstreams", default="", help="Comma-separated upstream URLs")
+    service.add_argument("--workers", action="store_true", help="Enable workers")
+    service.add_argument("--broker", choices=["redis", "rabbitmq"], default="redis")
+    service.add_argument("--caching", action="store_true", help="Enable caching")
+    service.add_argument("--cache-backend", choices=["redis"], default="redis")
+    service.add_argument(
+        "--structured-logging",
+        dest="structured_logging",
+        action="store_true",
+        default=True,
+        help="Enable structured logging",
+    )
+    service.add_argument(
+        "--no-structured-logging",
+        dest="structured_logging",
+        action="store_false",
+        help="Disable structured logging",
+    )
+    service.add_argument("--interactive", dest="interactive", action="store_true", default=None)
+    service.add_argument("--no-interactive", dest="interactive", action="store_false")
+    service.add_argument("--force", action="store_true", help="Overwrite existing generated path")
+
+    return parser
+
+
+def _list_features() -> int:
+    with features_path() as feature_lib:
+        names = sorted(
+            path.name
+            for path in feature_lib.iterdir()
+            if path.is_dir() and (path / "manifest.yaml").exists()
+        )
+    if not names:
+        print("No bundled features found.")
+        return 1
+    for name in names:
+        print(name)
+    return 0
+
+
+def _run_doctor(service: Path, as_json: bool) -> int:
+    report = run_doctor(service)
+    payload = {
+        "ok": report.ok,
+        "errors": report.errors,
+        "warnings": report.warnings,
+    }
+    if as_json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+    else:
+        if report.ok:
+            print("Doctor check passed.")
+        else:
+            print("Doctor check failed.")
+        for err in report.errors:
+            print(f"ERROR: {err}")
+        for warning in report.warnings:
+            print(f"WARN: {warning}")
+    return 0 if report.ok else 1
+
+
+def main() -> int:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    if args.command == "new" and args.new_command == "service":
+        try:
+            config = _collect_new_service_config(args)
+            generated = generate_service(**config)
+        except (FileExistsError, ValueError) as exc:
+            print(f"ERROR: {exc}")
+            return 1
+        except KeyboardInterrupt:
+            print("\nCancelled.")
+            return 1
+        print(f"Generated service at: {generated}")
+        return 0
+
+    if args.command == "doctor":
+        return _run_doctor(args.service, args.json)
+
+    if args.command != "feature" or args.feature_command not in {"add", "plan", "list"}:
+        parser.print_help()
+        return 0
+
+    if args.feature_command == "list":
+        return _list_features()
+
+    with features_path() as feature_lib:
+        augmentor = ServiceAugmentor(args.service, feature_lib)
+        if args.feature_command == "plan" and args.json:
+            plan = augmentor.build_plan(args.feature)
+            if plan is None:
+                return 1
+            print(
+                json.dumps(
+                    {
+                        "feature": args.feature,
+                        "service": str(args.service.resolve()),
+                        "modifies": plan["modifies"],
+                        "creates": plan["creates"],
+                    },
+                    indent=2,
+                    sort_keys=True,
+                )
+            )
+            return 0
+        success, changes = augmentor.add_feature(args.feature, plan=args.plan)
+
+    if not success:
+        return 1
+
+    if args.plan:
+        print("Plan validated.")
+    else:
+        print(f"Feature '{args.feature}' added.")
+        if changes:
+            for change in changes:
+                print(f"- {change}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{csrd_utils-0.3.2 → csrd_utils-0.3.5}/src/csrd_utils/augmentor.py

@@ -387,6 +387,7 @@ class ServiceAugmentor:
         tuple[bool, list[str]]
             (success, list of changes applied)
         """
+        self.applied_changes = []
         print(f"\n📦 Adding feature: {feature_name}")
         print()
 
@@ -430,8 +431,19 @@ class ServiceAugmentor:
         all_success &= self.create_feature_files(feature_name)
         all_success &= self.create_test_files(feature_name)
 
+        if not all_success:
+            self.rollback()
         return all_success, self.applied_changes
 
+    def build_plan(self, feature_name: str) -> dict[str, list[str]] | None:
+        """Return a structured dry-run plan for feature application."""
+        if not self.load_feature(feature_name):
+            return None
+        return {
+            "modifies": list(self.manifest.get("modifies", [])),
+            "creates": list(self.manifest.get("creates", [])),
+        }
+
     def rollback(self) -> None:
         """Restore all backups."""
         print("\n🔄 Rolling back changes...")
@@ -439,3 +451,4 @@ class ServiceAugmentor:
             shutil.copy2(backup_path, original_path)
             Path(backup_path).unlink()
             print(f"  Restored {original_path}")
+        self.backups.clear()

csrd_utils-0.3.5/src/csrd_utils/doctor.py

@@ -0,0 +1,46 @@
+"""Preflight checks for services targeted by csrd-utils feature augmentation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class DoctorReport:
+    """Structured doctor output."""
+
+    ok: bool
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+
+def run_doctor(service_root: Path) -> DoctorReport:
+    """Validate that a service is compatible with feature augmentation."""
+    root = service_root.resolve()
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    required_dirs = ["src/app", "tests"]
+    required_files = ["docker-compose.yml", "requirements.txt"]
+
+    for rel in required_dirs:
+        if not (root / rel).is_dir():
+            errors.append(f"Missing required directory: {rel}")
+
+    for rel in required_files:
+        if not (root / rel).is_file():
+            errors.append(f"Missing required file: {rel}")
+
+    marker_files = {
+        "src/app/settings.py": "# [INSERT: fields]",
+        "tests/conftest.py": "# [INSERT: fixtures]",
+    }
+    for rel, marker in marker_files.items():
+        path = root / rel
+        if path.exists():
+            text = path.read_text(encoding="utf-8")
+            if marker not in text:
+                warnings.append(f"Optional insertion marker missing in {rel}: {marker}")
+
+    return DoctorReport(ok=not errors, errors=errors, warnings=warnings)

csrd_utils-0.3.5/src/csrd_utils/features/workers/settings.fragment.py

@@ -0,0 +1,3 @@
+# [INSERT: fields]
+celery_broker_url: str = "redis://localhost:6379/0"
+celery_result_backend: str = "redis://localhost:6379/0"

{csrd_utils-0.3.2 → csrd_utils-0.3.5}/src/csrd_utils/fragments.py

@@ -170,6 +170,8 @@ class PythonFileMerger:
 
         # Insert fragment after the marker line
         fragment_lines = fragment_content.strip().split("\n")
+        if fragment_lines and re.match(r"^# \[INSERT:\s*\w+\]", fragment_lines[0]):
+            fragment_lines = fragment_lines[1:]
         for line in reversed(fragment_lines):
             lines.insert(insert_idx + 1, line)
 

csrd_utils-0.3.5/src/csrd_utils/generator.py

@@ -0,0 +1,107 @@
+"""Service generation helpers backed by bundled cookiecutter templates."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from cookiecutter.main import cookiecutter
+
+from .resources import templates_path
+
+
+def _build_context(
+    *,
+    name: str,
+    description: str,
+    port: int,
+    model_name: str,
+    model_name_plural: str,
+    has_database: bool,
+    database: str,
+    has_delegates: bool,
+    upstreams: str,
+    has_workers: bool,
+    broker: str,
+    has_caching: bool,
+    cache_backend: str,
+    has_structured_logging: bool,
+) -> dict[str, Any]:
+    return {
+        "service_name": name,
+        "service_description": description,
+        "port": str(port),
+        "model_name": model_name,
+        "model_name_plural": model_name_plural,
+        "has_database": has_database,
+        "database": database,
+        "has_delegates": has_delegates,
+        "upstreams": upstreams,
+        "has_workers": has_workers,
+        "broker": broker,
+        "has_caching": has_caching,
+        "cache_backend": cache_backend,
+        "has_structured_logging": has_structured_logging,
+    }
+
+
+def generate_service(
+    *,
+    name: str,
+    output_dir: Path,
+    description: str,
+    port: int,
+    model_name: str,
+    model_name_plural: str,
+    has_database: bool,
+    database: str,
+    has_delegates: bool,
+    upstreams: str,
+    has_workers: bool,
+    broker: str,
+    has_caching: bool,
+    cache_backend: str,
+    has_structured_logging: bool,
+    overwrite_if_exists: bool,
+) -> Path:
+    """Generate a service from the bundled cookiecutter-service template."""
+    output_root = output_dir.resolve()
+    output_root.mkdir(parents=True, exist_ok=True)
+    target = output_root / name
+
+    if target.exists() and any(target.iterdir()) and not overwrite_if_exists:
+        raise FileExistsError(
+            f"Target directory already exists and is not empty: {target}. Use --force to overwrite."
+        )
+
+    if has_delegates and not upstreams.strip():
+        raise ValueError("--upstreams is required when --delegates is enabled")
+
+    context = _build_context(
+        name=name,
+        description=description,
+        port=port,
+        model_name=model_name,
+        model_name_plural=model_name_plural,
+        has_database=has_database,
+        database=database,
+        has_delegates=has_delegates,
+        upstreams=upstreams,
+        has_workers=has_workers,
+        broker=broker,
+        has_caching=has_caching,
+        cache_backend=cache_backend,
+        has_structured_logging=has_structured_logging,
+    )
+
+    with templates_path() as template_root:
+        template = template_root / "cookiecutter-service"
+        generated = cookiecutter(
+            str(template),
+            no_input=True,
+            extra_context=context,
+            output_dir=str(output_root),
+            overwrite_if_exists=overwrite_if_exists,
+        )
+
+    return Path(generated).resolve()

{csrd_utils-0.3.2 → csrd_utils-0.3.5}/src/csrd_utils/templates/cookiecutter-service/{{cookiecutter.service_name}}/src/app/settings.py

@@ -4,6 +4,8 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
 
+    # [INSERT: fields]
+
     app_name: str = "{{ cookiecutter.service_name }}"
     port: int = {{ cookiecutter.port }}
     has_structured_logging: bool = {{ "True" if cookiecutter.has_structured_logging else "False" }}

{csrd_utils-0.3.2 → csrd_utils-0.3.5}/src/csrd_utils/templates/cookiecutter-service/{{cookiecutter.service_name}}/tests/conftest.py

@@ -15,6 +15,9 @@ HAS_DATABASE = {{ "True" if cookiecutter.has_database else "False" }}
 DB_KIND = "{{ cookiecutter.database }}"
 
 
+# [INSERT: fixtures]
+
+
 @pytest.fixture
 def client():
     if HAS_DATABASE and DB_KIND == "maria":

csrd_utils-0.3.2/PKG-INFO

@@ -1,46 +0,0 @@
-Metadata-Version: 2.4
-Name: csrd-utils
-Version: 0.3.2
-Summary: CLI utilities for csrd service generation and feature augmentation
-Project-URL: Repository, https://github.com/csrd-api/fastapi-common
-Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/utils
-Project-URL: Changelog, https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md
-License: MIT
-Requires-Python: >=3.12
-Requires-Dist: pyyaml<7,>=6
-Description-Content-Type: text/markdown
-
-# csrd-utils
-
-CLI and runtime helpers for generating csrd services and augmenting existing services with optional features.
-
-## Install
-
-```bash
-pip install "csrd-utils @ git+https://github.com/csrd-api/fastapi-common.git#subdirectory=packages/utils"
-```
-
-## CLI
-
-```bash
-csrd --help
-csrd feature plan workers --service .
-csrd feature add workers --service .
-```
-
-## Bundled assets
-
-- `features/workers/` feature manifests and fragments
-- `templates/cookiecutter-service/` template starter
-
-## Python API
-
-```python
-from pathlib import Path
-from csrd_utils import ServiceAugmentor
-from csrd_utils.resources import features_path
-
-with features_path() as feature_lib:
-    augmentor = ServiceAugmentor(Path("."), feature_lib)
-    ok, changes = augmentor.add_feature("workers", plan=True)
-```

csrd_utils-0.3.2/README.md

@@ -1,34 +0,0 @@
-# csrd-utils
-
-CLI and runtime helpers for generating csrd services and augmenting existing services with optional features.
-
-## Install
-
-```bash
-pip install "csrd-utils @ git+https://github.com/csrd-api/fastapi-common.git#subdirectory=packages/utils"
-```
-
-## CLI
-
-```bash
-csrd --help
-csrd feature plan workers --service .
-csrd feature add workers --service .
-```
-
-## Bundled assets
-
-- `features/workers/` feature manifests and fragments
-- `templates/cookiecutter-service/` template starter
-
-## Python API
-
-```python
-from pathlib import Path
-from csrd_utils import ServiceAugmentor
-from csrd_utils.resources import features_path
-
-with features_path() as feature_lib:
-    augmentor = ServiceAugmentor(Path("."), feature_lib)
-    ok, changes = augmentor.add_feature("workers", plan=True)
-```

csrd_utils-0.3.2/src/csrd_utils/__init__.py

@@ -1,5 +0,0 @@
-"""csrd-utils: template and feature tooling for csrd services."""
-
-from .augmentor import ServiceAugmentor
-
-__all__ = ["ServiceAugmentor"]

csrd_utils-0.3.2/src/csrd_utils/__main__.py

@@ -1,55 +0,0 @@
-"""Command-line interface for csrd-utils."""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from .augmentor import ServiceAugmentor
-from .resources import features_path
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="csrd", description="csrd utilities")
-    sub = parser.add_subparsers(dest="command")
-
-    feature = sub.add_parser("feature", help="Feature operations")
-    feature_sub = feature.add_subparsers(dest="feature_command")
-
-    for name, plan in (("add", False), ("plan", True)):
-        cmd = feature_sub.add_parser(name, help=f"{name} feature")
-        cmd.add_argument("feature", help="Feature name, e.g. workers")
-        cmd.add_argument("--service", type=Path, default=Path.cwd(), help="Service root path")
-        cmd.set_defaults(plan=plan)
-
-    return parser
-
-
-def main() -> int:
-    parser = _build_parser()
-    args = parser.parse_args()
-
-    if args.command != "feature" or args.feature_command not in {"add", "plan"}:
-        parser.print_help()
-        return 0
-
-    with features_path() as feature_lib:
-        augmentor = ServiceAugmentor(args.service, feature_lib)
-        success, changes = augmentor.add_feature(args.feature, plan=args.plan)
-
-    if not success:
-        return 1
-
-    if args.plan:
-        print("Plan validated.")
-    else:
-        print(f"Feature '{args.feature}' added.")
-        if changes:
-            for change in changes:
-                print(f"- {change}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

csrd_utils-0.3.2/src/csrd_utils/features/workers/settings.fragment.py

@@ -1,9 +0,0 @@
-# [INSERT: fields]
-celery_broker_url: str = Field(  # noqa: F821
-    default="redis://localhost:6379/0",
-    description="Celery broker URL",
-)
-celery_result_backend: str = Field(  # noqa: F821
-    default="redis://localhost:6379/0",
-    description="Celery result backend URL",
-)