model-generator-kit 0.1.0__py3-none-any.whl

model_generator/generators/__init__.py

@@ -0,0 +1,38 @@
+"""
+Code generators for model-generator.
+"""
+
+from .api import (
+    generate_api_init,
+    generate_api_models,
+    generate_api_pagination,
+    generate_api_routes,
+    generate_api_tests,
+)
+from .constraints import generate_constraints
+from .database import generate_database_model, generate_factories, generate_init
+from .enums import generate_enums
+from .infrastructure import (
+    generate_gitignore,
+    generate_infrastructure,
+    generate_pyproject,
+)
+from .migrations import generate_migration_autogen, generate_migration_init
+
+__all__ = [
+    "generate_api_init",
+    "generate_api_models",
+    "generate_api_pagination",
+    "generate_api_routes",
+    "generate_api_tests",
+    "generate_constraints",
+    "generate_database_model",
+    "generate_enums",
+    "generate_factories",
+    "generate_gitignore",
+    "generate_infrastructure",
+    "generate_init",
+    "generate_migration_autogen",
+    "generate_migration_init",
+    "generate_pyproject",
+]

model_generator/generators/api.py

@@ -0,0 +1,287 @@
+"""
+API generation utilities (models, routes, tests).
+"""
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment
+
+from ..utils.loaders import get_layout, load_shared_constraints, load_shared_enums
+from ..utils.parser import scan_api_model_files
+from ..utils.templates import snake_case
+
+
+def _filter_api_entities(model: dict[str, Any]) -> dict[str, Any] | None:
+    """Return model copy with only API-enabled entities, or None if none."""
+    entities = {
+        name: entity
+        for name, entity in model.get("entities", {}).items()
+        if entity.get("api", {}).get("enabled", True)
+    }
+    if not entities:
+        return None
+    return {**model, "entities": entities}
+
+
+def _filter_test_entities(model: dict[str, Any]) -> dict[str, Any] | None:
+    """Return model copy with only test-enabled entities, or None if none."""
+    entities = {
+        name: entity
+        for name, entity in model.get("entities", {}).items()
+        if entity.get("tests", {}).get("enabled", True)
+    }
+    if not entities:
+        return None
+    return {**model, "entities": entities}
+
+
+def generate_api_models(
+    model: dict[str, Any],
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    model_path: Path | None = None,
+) -> list[dict[str, Any]] | None:
+    """Generate Pydantic response and request models.
+
+    In per-entity layout (the default) returns two files per entity
+    (``{entity_snake}_response.py`` + ``{entity_snake}_requests.py``). In
+    per-domain layout returns one combined response file and one combined
+    request file. Templates iterate ``model.entities`` so per-entity mode
+    just feeds them sliced inputs — no template change required.
+    """
+    filtered = _filter_api_entities(model)
+    if filtered is None:
+        return None
+
+    enums = load_shared_enums(model_path or project_root)
+    output_dir = project_root / config["paths"]["api_models"]
+    response_template = env.get_template("api/response.py.j2")
+    request_template = env.get_template("api/request.py.j2")
+
+    if get_layout(config) == "per-entity":
+        outputs = []
+        for name, entity in filtered.get("entities", {}).items():
+            sliced = {**filtered, "entities": {name: entity}}
+            stem = snake_case(name)
+            outputs.append(
+                {
+                    "path": output_dir / f"{stem}_response.py",
+                    "content": response_template.render(
+                        model=sliced, config=config, enums=enums
+                    ),
+                }
+            )
+            outputs.append(
+                {
+                    "path": output_dir / f"{stem}_requests.py",
+                    "content": request_template.render(
+                        model=sliced, config=config, enums=enums
+                    ),
+                }
+            )
+        return outputs
+
+    domain = filtered.get("domain", "models")
+    return [
+        {
+            "path": output_dir / f"{domain}_response.py",
+            "content": response_template.render(
+                model=filtered, config=config, enums=enums
+            ),
+        },
+        {
+            "path": output_dir / f"{domain}_requests.py",
+            "content": request_template.render(
+                model=filtered, config=config, enums=enums
+            ),
+        },
+    ]
+
+
+def generate_api_init(
+    model: dict[str, Any], config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate __init__.py with exports for all API model files."""
+    output_dir = project_root / config["paths"]["api_models"]
+    domains = scan_api_model_files(output_dir)
+    filtered = _filter_api_entities(model)
+
+    if get_layout(config) == "per-entity":
+        existing_names = {d["name"] for d in domains}
+        if filtered is not None:
+            for entity_name, entity in filtered.get("entities", {}).items():
+                stem = snake_case(entity_name)
+                if stem in existing_names:
+                    continue
+                request_models = [f"Create{entity_name}Request"]
+                if entity.get("mutability", "mutable") != "immutable":
+                    request_models.append(f"Update{entity_name}Request")
+                domains.append(
+                    {
+                        "name": stem,
+                        "section": None,
+                        "response_models": [f"{entity_name}Response"],
+                        "request_models": request_models,
+                    }
+                )
+    else:
+        current_domain = model.get("domain", "unknown")
+        domain_names = {d["name"] for d in domains}
+        if filtered is not None and current_domain not in domain_names:
+            entities = list(filtered.get("entities", {}).keys())
+            domains.append(
+                {
+                    "name": current_domain,
+                    "section": current_domain.upper().replace("_", " ") + " MODELS",
+                    "response_models": [f"{e}Response" for e in entities],
+                    "request_models": [f"Create{e}Request" for e in entities]
+                    + [
+                        f"Update{e}Request"
+                        for e in entities
+                        if filtered["entities"][e].get("mutability", "mutable")
+                        != "immutable"
+                    ],
+                }
+            )
+
+    if not domains:
+        print(f"  ℹ️  No API model files found in {output_dir}")
+        return None
+
+    total_responses = sum(len(d["response_models"]) for d in domains)
+    total_requests = sum(len(d["request_models"]) for d in domains)
+
+    template = env.get_template("api/init.py.j2")
+    content = template.render(domains=domains, config=config)
+
+    return {
+        "path": output_dir / "__init__.py",
+        "content": content,
+        "mode": "write",
+        "domain_count": len(domains),
+        "response_count": total_responses,
+        "request_count": total_requests,
+    }
+
+
+def generate_api_pagination(
+    model: dict[str, Any], config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate pagination.py with reusable pagination models."""
+    output_dir = project_root / config["paths"]["api_models"]
+    pagination_file = output_dir / "pagination.py"
+
+    if pagination_file.exists():
+        print(f"  ℹ️  Pagination file already exists at {pagination_file}")
+        print("     To regenerate, delete the file first")
+        return None
+
+    template = env.get_template("api/pagination.py.j2")
+    content = template.render(config=config)
+
+    return {"path": pagination_file, "content": content, "mode": "write"}
+
+
+def generate_api_routes(
+    model: dict[str, Any],
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    enums: dict[str, Any] | None = None,
+    constraints: dict[str, Any] | None = None,
+    model_path: Path | None = None,
+) -> dict[str, Any] | list[dict[str, Any]] | None:
+    """Generate FastAPI routes.
+
+    In per-entity layout (the default) returns one dict per entity at
+    ``routes/{entity_snake}.py``; in per-domain layout returns a single
+    dict at ``routes/{domain}.py``. The route template adapts its DB-model
+    and api-model imports based on ``config.generation.layout``.
+    """
+    filtered = _filter_api_entities(model)
+    if filtered is None:
+        return None
+
+    if enums is None:
+        enums = load_shared_enums(model_path or project_root)
+    if constraints is None:
+        constraints = load_shared_constraints(model_path or project_root)
+
+    template = env.get_template("api/route.py.j2")
+    output_dir = project_root / config["paths"]["api_routes"]
+
+    if get_layout(config) == "per-entity":
+        return [
+            {
+                "path": output_dir / f"{snake_case(name)}.py",
+                "content": template.render(
+                    model={**filtered, "entities": {name: entity}},
+                    config=config,
+                    enums=enums,
+                    constraints=constraints,
+                ),
+            }
+            for name, entity in filtered.get("entities", {}).items()
+        ]
+
+    domain = filtered.get("domain", "models")
+    content = template.render(
+        model=filtered, config=config, enums=enums, constraints=constraints
+    )
+    return {"path": output_dir / f"{domain}.py", "content": content}
+
+
+def generate_api_tests(
+    model: dict[str, Any],
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    enums: dict[str, Any] | None = None,
+    constraints: dict[str, Any] | None = None,
+    model_path: Path | None = None,
+) -> dict[str, Any] | list[dict[str, Any]] | None:
+    """Generate API contract tests.
+
+    In per-entity layout (the default) returns one dict per entity at
+    ``tests/api/test_{entity_snake}_api.py``; in per-domain layout returns
+    a single dict at ``tests/api/test_{domain}_api.py``. The contract
+    template iterates ``model.entities`` and has no cross-entity imports,
+    so per-entity mode just feeds it sliced inputs — no template change.
+    """
+    # Both API and tests must be enabled
+    filtered = _filter_api_entities(model)
+    if filtered is None:
+        return None
+    filtered = _filter_test_entities(filtered)
+    if filtered is None:
+        return None
+
+    if enums is None:
+        enums = load_shared_enums(model_path or project_root)
+    if constraints is None:
+        constraints = load_shared_constraints(model_path or project_root)
+
+    template = env.get_template("tests/contract.py.j2")
+    output_dir = project_root / config["paths"]["api_tests"]
+
+    if get_layout(config) == "per-entity":
+        return [
+            {
+                "path": output_dir / f"test_{snake_case(name)}_api.py",
+                "content": template.render(
+                    model={**filtered, "entities": {name: entity}},
+                    config=config,
+                    enums=enums,
+                    constraints=constraints,
+                ),
+            }
+            for name, entity in filtered.get("entities", {}).items()
+        ]
+
+    domain = filtered.get("domain", "models")
+    content = template.render(
+        model=filtered, config=config, enums=enums, constraints=constraints
+    )
+    return {"path": output_dir / f"test_{domain}_api.py", "content": content}

model_generator/generators/constraints.py

@@ -0,0 +1,176 @@
+"""
+Constraint generation utilities.
+"""
+
+import re
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment
+
+from ..utils.loaders import load_shared_constraints
+
+
+def get_existing_constraints(constraints_file: Path) -> set[str]:
+    """Parse existing constraints.py to find defined constant names."""
+    if not constraints_file.exists():
+        return set()
+
+    content = constraints_file.read_text()
+    pattern = r"^([A-Z][A-Z0-9_]*)\s*="
+    return set(re.findall(pattern, content, re.MULTILINE))
+
+
+def extract_constraint_refs(
+    model: dict[str, Any], shared_constraints: dict[str, Any]
+) -> list[dict[str, Any]]:
+    """Extract all constraint references from model field definitions."""
+    refs: list[dict[str, Any]] = []
+    seen: set[str] = set()
+
+    for entity in model.get("entities", {}).values():
+        for field_name, field in entity.get("fields", {}).items():
+            for constraint in field.get("constraints", []):
+                _extract_ref(
+                    constraint,
+                    "min_ref",
+                    shared_constraints,
+                    field_name,
+                    refs,
+                    seen,
+                    is_min=True,
+                )
+                _extract_ref(
+                    constraint,
+                    "max_ref",
+                    shared_constraints,
+                    field_name,
+                    refs,
+                    seen,
+                    is_min=False,
+                )
+                _extract_regex_ref(
+                    constraint, shared_constraints, field_name, refs, seen
+                )
+
+    return refs
+
+
+def _extract_ref(
+    constraint: dict[str, Any],
+    ref_key: str,
+    shared_constraints: dict[str, Any],
+    field_name: str,
+    refs: list[dict[str, Any]],
+    seen: set[str],
+    is_min: bool,
+) -> None:
+    """Extract min_ref or max_ref from constraint."""
+    if ref_key not in constraint or constraint[ref_key] in seen:
+        return
+
+    ref_name = constraint[ref_key]
+    ref_def = shared_constraints.get(ref_name, {})
+    refs.append(
+        {
+            "name": ref_name,
+            "type": ref_def.get("type", constraint.get("type", "decimal")),
+            "field": field_name,
+            "is_min": is_min,
+            "value": ref_def.get("value"),
+            "description": ref_def.get("description"),
+        }
+    )
+    seen.add(ref_name)
+
+
+def _extract_regex_ref(
+    constraint: dict[str, Any],
+    shared_constraints: dict[str, Any],
+    field_name: str,
+    refs: list[dict[str, Any]],
+    seen: set[str],
+) -> None:
+    """Extract regex_ref from constraint."""
+    if "regex_ref" not in constraint or constraint["regex_ref"] in seen:
+        return
+
+    ref_name = constraint["regex_ref"]
+    ref_def = shared_constraints.get(ref_name, {})
+    refs.append(
+        {
+            "name": ref_name,
+            "type": "pattern",
+            "field": field_name,
+            "value": ref_def.get("value"),
+            "description": ref_def.get("description"),
+        }
+    )
+    seen.add(ref_name)
+
+
+def generate_constraints(
+    model: dict[str, Any],
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    model_path: Path | None = None,
+) -> dict[str, Any] | None:
+    """
+    Generate constraint constants from _shared/constraints.json.
+
+    Creates file if missing, appends new constraints if file exists.
+    """
+    shared_constraints = load_shared_constraints(
+        model_path if model_path is not None else project_root
+    )
+    all_refs = extract_constraint_refs(model, shared_constraints)
+
+    if not all_refs:
+        return None
+
+    output_dir = project_root / config["paths"]["database_models"]
+    constraints_file = output_dir / "constraints.py"
+    file_exists = constraints_file.exists()
+
+    if file_exists:
+        existing = get_existing_constraints(constraints_file)
+        new_refs = [ref for ref in all_refs if ref["name"] not in existing]
+
+        if not new_refs:
+            print(f"  ℹ️  All constraint constants already exist in {constraints_file}")
+            return None
+
+        template = env.get_template("database/constraints.py.j2")
+        content = template.render(
+            mode="append",
+            section_header="CONSTRAINTS",
+            constraints=new_refs,
+            include_helpers=False,
+            config=config,
+        )
+
+        return {
+            "path": constraints_file,
+            "content": "\n" + content,
+            "mode": "append",
+            "new_count": len(new_refs),
+            "skipped": len(all_refs) - len(new_refs),
+        }
+    else:
+        template = env.get_template("database/constraints.py.j2")
+        content = template.render(
+            mode="create",
+            section_header="CONSTRAINTS",
+            constraints=all_refs,
+            include_helpers=True,
+            config=config,
+        )
+
+        return {
+            "path": constraints_file,
+            "content": content,
+            "mode": "write",
+            "new_count": len(all_refs),
+            "skipped": 0,
+        }

model_generator/generators/database.py

@@ -0,0 +1,147 @@
+"""
+Database model generation utilities.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment
+
+from ..utils.loaders import get_layout, load_shared_constraints
+from ..utils.parser import scan_model_files
+from ..utils.templates import snake_case
+
+
+def generate_database_model(
+    model: dict[str, Any], config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | list[dict[str, Any]]:
+    """Generate SQLAlchemy database model(s).
+
+    In per-entity layout (the default) returns one dict per entity, each
+    pointing at ``{entity_snake}.py``. In per-domain layout returns a single
+    dict pointing at ``{domain}.py`` with all entities in one file.
+    """
+    template = env.get_template("database/model.py.j2")
+    output_dir = project_root / config["paths"]["database_models"]
+    sibling_entities = list(model.get("entities", {}).keys())
+
+    if get_layout(config) == "per-entity":
+        return [
+            {
+                "path": output_dir / f"{snake_case(name)}.py",
+                "content": template.render(
+                    model={**model, "entities": {name: entity}},
+                    config=config,
+                    sibling_entities=sibling_entities,
+                ),
+            }
+            for name, entity in model.get("entities", {}).items()
+        ]
+
+    domain = model.get("domain", "models")
+    content = template.render(
+        model=model, config=config, sibling_entities=sibling_entities
+    )
+    return {"path": output_dir / f"{domain}.py", "content": content}
+
+
+def generate_init(
+    model: dict[str, Any], config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate __init__.py with exports for all model files."""
+    output_dir = project_root / config["paths"]["database_models"]
+    domains = scan_model_files(output_dir)
+
+    if get_layout(config) == "per-entity":
+        existing_files = {d["file"] for d in domains}
+        for name in model.get("entities", {}).keys():
+            stem = snake_case(name)
+            if stem not in existing_files:
+                domains.append(
+                    {
+                        "name": stem,
+                        "file": stem,
+                        "section": None,
+                        "entities": [name],
+                    }
+                )
+    else:
+        current_domain = model.get("domain", "unknown")
+        domain_names = {d["name"] for d in domains}
+        if current_domain not in domain_names:
+            domains.append(
+                {
+                    "name": current_domain,
+                    "file": current_domain,
+                    "section": model.get("section_header"),
+                    "entities": list(model.get("entities", {}).keys()),
+                }
+            )
+
+    if not domains:
+        print(f"  ℹ️  No model files found in {output_dir}")
+        return None
+
+    total_entities = sum(len(d["entities"]) for d in domains)
+
+    template = env.get_template("database/init.py.j2")
+    content = template.render(domains=domains, config=config)
+
+    return {
+        "path": output_dir / "__init__.py",
+        "content": content,
+        "mode": "write",
+        "domain_count": len(domains),
+        "entity_count": total_entities,
+    }
+
+
+def generate_factories(
+    model: dict[str, Any],
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    model_path: Path | None = None,
+    constraints: dict[str, Any] | None = None,
+) -> dict[str, Any] | list[dict[str, Any]]:
+    """Generate FactoryBoy factories for test data generation.
+
+    Per-entity layout returns one factory file per entity; per-domain returns
+    a single combined file. ``sibling_entities`` (the full domain entity
+    list) is threaded into the template so cross-entity ``create_related``
+    blocks survive the per-entity slicing of ``model.entities``.
+
+    ``constraints`` (the flattened shared-constraint dict) is threaded into
+    the template so ``min_ref`` / ``max_ref`` bounds on financial/counter
+    fields resolve to literal values at generation time — the factory module
+    never imports the constraints module, so emitting the bare constant name
+    would ``NameError`` at ``create()`` time.
+    """
+    template = env.get_template("database/factory.py.j2")
+    factories_dir = project_root / config["paths"]["database_models"] / "factories"
+    sibling_entities = list(model.get("entities", {}).keys())
+    if constraints is None:
+        constraints = load_shared_constraints(model_path or project_root)
+
+    if get_layout(config) == "per-entity":
+        return [
+            {
+                "path": factories_dir / f"{snake_case(name)}.py",
+                "content": template.render(
+                    model={**model, "entities": {name: entity}},
+                    config=config,
+                    sibling_entities=sibling_entities,
+                    constraints=constraints,
+                ),
+            }
+            for name, entity in model.get("entities", {}).items()
+        ]
+
+    domain = model.get("domain", "models")
+    content = template.render(
+        model=model,
+        config=config,
+        sibling_entities=sibling_entities,
+        constraints=constraints,
+    )
+    return {"path": factories_dir / f"{domain}.py", "content": content}