kraf 0.1.0__py3-none-any.whl

kraf-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: kraf
+Version: 0.1.0
+Summary: Interactive Python web project initializer for Django, Django REST Framework, and FastAPI.
+Requires-Python: >=3.11
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: questionary>=2.1.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# kraf
+
+Interactive Python web project initializer for Django, Django REST Framework, and FastAPI.
+
+## Install
+
+```bash
+pipx install kraf
+```
+
+## Usage
+
+```bash
+kraf init
+```
+
+The CLI asks for:
+
+- Project name
+- Project type: Django, Django with DRF, or FastAPI
+- Database: no database, SQLite, or PostgreSQL
+- FastAPI ORM and migration choices
+- Tooling choices: pytest, Ruff, and Docker
+
+Generated projects include:
+
+- `Makefile`
+- `.env.example`
+- `.gitignore`
+- `README.md`
+- Runtime dependencies in `requirements.txt`
+- Development dependencies in `requirements-dev.txt`
+
+Common generated commands:
+
+```bash
+make venv
+make install
+make run
+make test
+make lint
+make format
+make migrate
+```
+
+## Development
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+ruff check src tests
+```

kraf-0.1.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+project_initializer/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+project_initializer/cli.py,sha256=SPRbHydzYGNGiUFi91fQane1st52JRLzYrxqPyQRRUY,2016
+project_initializer/config.py,sha256=Bct2FpZhcMQAhtUqtiBAW78jDziKntnKDh8gLGR5apA,2465
+project_initializer/errors.py,sha256=ermipxkkNJf9eNpvnuTOpeI2wleFYHAr2knlNUVfbk0,465
+project_initializer/name_utils.py,sha256=tx5-eX082z4W5Bul_pSJocuaMdiz188upmfd-M-A_6s,1191
+project_initializer/pack.py,sha256=Hm4dG8EIvQLgxy0S55CpXnwpzjJLEiAEXUmk9VJhb4g,6867
+project_initializer/prompts.py,sha256=C0Z885RVnGQjItfeZFtYYG8-Q-px3X3nZ-oA-bkMNco,5429
+project_initializer/renderer.py,sha256=GrPlMhMMEyWB6FIr-SlnX-UMzYzfyXCwHkT4rl_dVtI,5878
+project_initializer/resources.py,sha256=dtL-Mf1sBiqy179eqqWF5ksKIew0I50flTSfa6C2m1E,243
+project_initializer/packs/common/pack.yaml,sha256=_v_34fXXEqwmSnjcCFEn3S0pqUnrwW1ZVVLEXo5_rnU,201
+project_initializer/packs/common/templates/.gitignore.j2,sha256=hGLkME_f24y8OeFJYPNkbThaRkxvhbSuyIkD0T5CTds,74
+project_initializer/packs/common/templates/README.md.j2,sha256=DofEoghs8P3k_HE26culIwUFJTG8HjPbzGySsXeCIhw,262
+project_initializer/packs/database_postgres/pack.yaml,sha256=h2hO9iYpiwXFJpBTak2LBUUJgHbWq-b92x4o_93RKUs,129
+project_initializer/packs/database_sqlite/pack.yaml,sha256=Ahg601zlKKTOiJ1f5imavge_4AmF5xfEUpVDEuGhDKY,64
+project_initializer/packs/django/pack.yaml,sha256=xpBHDSlDrlRLrkKXyK1S45Ys6ZLhWcw3Qoslz4J_O-U,725
+project_initializer/packs/django/templates/manage.py.j2,sha256=mZePL41rWhgzYtCka8xPnKbPuRSmF8bzJIw6xe4TUDs,302
+project_initializer/packs/django/templates/project/__init__.py.j2,sha256=n10dVDJufwarAfDH4BJ_44Q9ENIGNSDmQ8pyVulQ40Q,36
+project_initializer/packs/django/templates/project/asgi.py.j2,sha256=_vKq1jq8N3HXNCxOjNsdA82bONQV6yYhK4pdEhujmlk,187
+project_initializer/packs/django/templates/project/settings.py.j2,sha256=kzrrXljqPXrriMB0CYJsE0uFZvDD9kt0qqY1kkvGiso,2466
+project_initializer/packs/django/templates/project/urls.py.j2,sha256=wpCopp_n-Z2k6_xaiW5qcjMfJj-UPdnWLW5sMvFbIOw,334
+project_initializer/packs/django/templates/project/wsgi.py.j2,sha256=87NAin_P4MDI0OThHXk1G51ih4jO9iwWlK8Bu6DVI6o,187
+project_initializer/packs/django_drf/pack.yaml,sha256=Ohh5PGyRkJbtM8LY7g4bstAS1cZ0h8-fQ3tI9On5LjI,284
+project_initializer/packs/django_drf/templates/api/__init__.py.j2,sha256=GQU1tAKpALcoNTm0IxRru4urEtmSxS31lQegQJ9xnwA,47
+project_initializer/packs/django_drf/templates/api/urls.py.j2,sha256=joG9AkPd0H2C11_bsG-xO19gwzHOn01d6_aB_PtAiyA,140
+project_initializer/packs/django_drf/templates/api/views.py.j2,sha256=gT8MX9VXDaITRg5qGokRAnEY6gK4hBigpF242xWSwYo,178
+project_initializer/packs/django_models/pack.yaml,sha256=8M8PFCOEOx1Yhcingv0e6XIX3nyQP11p--djDZoJvbc,199
+project_initializer/packs/django_models/templates/core/__init__.py.j2,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+project_initializer/packs/django_models/templates/core/models.py.j2,sha256=5BcpJ3f5cxzHNIyh7remCcDkh9Da_DLWkYeHW7R0Gb8,367
+project_initializer/packs/docker/pack.yaml,sha256=eYcQ9hV6mowc03aHrvx15Yy2dTPDa-VGFCB14FuRz6g,236
+project_initializer/packs/docker/templates/Dockerfile.j2,sha256=SGgahHZm3IViFONVDbnFcOOo0aRBzxvLAkyLVWmHiRw,303
+project_initializer/packs/docker/templates/docker-compose.yml.j2,sha256=rnAwbkUwuKFNAxWxt4v1-2fFTpE7BRUZPqS53sLAAqI,678
+project_initializer/packs/fastapi/pack.yaml,sha256=1Mao3BnyHSHIeMX9sElusiruzcdLp2E49eroQKWslYM,301
+project_initializer/packs/fastapi/templates/app/main.py.j2,sha256=MwtA16Xt2RhfoxM1t75yRVf4jqqbtKdy7DeWVJdQou4,165
+project_initializer/packs/fastapi/templates/app/api/health.py.j2,sha256=KkvNTc-plGDKt_RarG5dDIUCNLgwjeZ-tUgW0v3aiQc,169
+project_initializer/packs/migrations_alembic/pack.yaml,sha256=R7j_XUJ6IUXirT5P5bl6dPDVD5I5uYuhODdvVQKZCqU,349
+project_initializer/packs/migrations_alembic/templates/alembic.ini.j2,sha256=yrwk2p9_cF_sYIJrXnEQHxrTFVogTiMVkll-X3ffMuM,569
+project_initializer/packs/migrations_alembic/templates/alembic/env.py.j2,sha256=1-vu7alY9_bYvvtPo8omZVn3unQEI3RGXw1vLZdouLA,1245
+project_initializer/packs/orm_sqlalchemy/pack.yaml,sha256=5IRahqdga7_CULQMvbjL58Z9rpI9mVer5mlBQWrM_Ko,275
+project_initializer/packs/orm_sqlalchemy/templates/app/db/base.py.j2,sha256=7hjJLOID0XDa5yFGYm7kszTt3p1WVE6e25qfMxjdj_w,750
+project_initializer/packs/orm_sqlalchemy/templates/app/db/models.py.j2,sha256=p4SMDBIBVYxnGZSj0Qvs8YGjWS20PaknYJt_BZK8roo,194
+project_initializer/packs/orm_sqlalchemy/templates/app/db/session.py.j2,sha256=L1Y_TA_j2Vyh4FShjy-bIZ-KQIgAiwP4SzwdNxS9qcE,268
+project_initializer/packs/tooling_pytest/pack.yaml,sha256=5FOALYdx2DFaNkHnRFLQu8H7-wC0OF1qzE_fI3REDdY,99
+project_initializer/packs/tooling_ruff/pack.yaml,sha256=qduPLJKbbbdRhOl-0z7QRjafHZl-fQ6yUK6I6smBGYI,145
+kraf-0.1.0.dist-info/METADATA,sha256=foR8-MMAZP01X5k69PYHCSnYb1op4zzHD6FKKPYd_FI,1259
+kraf-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+kraf-0.1.0.dist-info/entry_points.txt,sha256=zIl37XEszwXvcbP8GGCrdAQ0Vu_pePx63pSB71TKcnY,53
+kraf-0.1.0.dist-info/RECORD,,

kraf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

kraf-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kraf = project_initializer.cli:app

project_initializer/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

project_initializer/cli.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from project_initializer import __version__
+from project_initializer.config import normalize_answers
+from project_initializer.errors import ProjectInitializerError
+from project_initializer.pack import resolve_packs
+from project_initializer.prompts import collect_answers
+from project_initializer.renderer import render_project
+from project_initializer.resources import builtin_pack_dirs
+
+app = typer.Typer(
+    name="kraf",
+    help="Create production-ready Python web projects from interactive prompts.",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kraf {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            help="Show the installed kraf version.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = False,
+) -> None:
+    return None
+
+
+@app.command()
+def init(
+    target_root: Annotated[
+        Path | None,
+        typer.Option(
+            "--target-root",
+            help="Directory where the generated project folder is created.",
+        ),
+    ] = None,
+) -> None:
+    _generate(target_root or Path.cwd())
+
+
+def _generate(target_root: Path) -> None:
+    try:
+        raw_answers = collect_answers()
+        config = normalize_answers(raw_answers, base_dir=target_root)
+        pack_dirs = {pack_dir.name: pack_dir for pack_dir in builtin_pack_dirs()}
+        packs = resolve_packs(config)
+        result = render_project(config, [(pack, pack_dirs[pack.name]) for pack in packs])
+    except ProjectInitializerError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    typer.echo(f"Created project at {result.path}")
+    typer.echo("Next steps:")
+    typer.echo(f"  cd {result.path}")
+    typer.echo("  make venv")
+    typer.echo("  make install")
+    typer.echo("  make run")

project_initializer/config.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+from project_initializer.errors import InvalidProjectNameError
+from project_initializer.name_utils import normalize_package_name, normalize_project_slug
+
+
+class ProjectType(StrEnum):
+    DJANGO = "django"
+    DJANGO_DRF = "django_drf"
+    FASTAPI = "fastapi"
+
+
+class Database(StrEnum):
+    NONE = "none"
+    SQLITE = "sqlite"
+    POSTGRESQL = "postgresql"
+
+
+@dataclass(frozen=True)
+class ToolingOptions:
+    use_docker: bool
+    use_pytest: bool
+    use_ruff: bool
+
+
+@dataclass(frozen=True)
+class ProjectConfig:
+    project_name: str
+    project_slug: str
+    package_name: str
+    target_dir: Path
+    project_type: ProjectType
+    database: Database
+    tooling: ToolingOptions
+    use_sqlalchemy: bool
+    use_alembic: bool
+
+
+def normalize_answers(raw_answers: dict[str, Any], base_dir: Path | None = None) -> ProjectConfig:
+    raw_project_name = raw_answers.get("project_name")
+    if raw_project_name is None:
+        raise InvalidProjectNameError("Project name is required.")
+    if not isinstance(raw_project_name, str):
+        raise InvalidProjectNameError("Project name must be text.")
+
+    project_name = raw_project_name.strip()
+    project_type = ProjectType(str(raw_answers["project_type"]))
+    database = Database(str(raw_answers["database"]))
+    package_name = normalize_package_name(project_name)
+    project_slug = normalize_project_slug(project_name)
+    target_root = base_dir or Path.cwd()
+
+    use_sqlalchemy = bool(raw_answers.get("use_sqlalchemy", False))
+    use_alembic = bool(raw_answers.get("use_alembic", False))
+    if project_type is not ProjectType.FASTAPI:
+        use_sqlalchemy = False
+        use_alembic = False
+    if database is Database.NONE:
+        use_sqlalchemy = False
+        use_alembic = False
+    if not use_sqlalchemy:
+        use_alembic = False
+
+    return ProjectConfig(
+        project_name=project_name,
+        project_slug=project_slug,
+        package_name=package_name,
+        target_dir=target_root / project_slug,
+        project_type=project_type,
+        database=database,
+        tooling=ToolingOptions(
+            use_docker=bool(raw_answers.get("use_docker", False)),
+            use_pytest=bool(raw_answers.get("use_pytest", True)),
+            use_ruff=bool(raw_answers.get("use_ruff", True)),
+        ),
+        use_sqlalchemy=use_sqlalchemy,
+        use_alembic=use_alembic,
+    )

project_initializer/errors.py

@@ -0,0 +1,14 @@
+class ProjectInitializerError(Exception):
+    """Base class for user-facing project initializer errors."""
+
+
+class InvalidProjectNameError(ProjectInitializerError):
+    """Raised when a project name cannot produce a valid slug or package name."""
+
+
+class PackError(ProjectInitializerError):
+    """Raised when pack manifests or pack selections are invalid."""
+
+
+class RenderError(ProjectInitializerError):
+    """Raised when a project cannot be rendered safely."""

project_initializer/name_utils.py

@@ -0,0 +1,36 @@
+import keyword
+import re
+
+from project_initializer.errors import InvalidProjectNameError
+
+_NON_ALNUM = re.compile(r"[^A-Za-z0-9]+")
+_MULTIPLE_DASHES = re.compile(r"-+")
+_MULTIPLE_UNDERSCORES = re.compile(r"_+")
+
+
+def normalize_project_slug(project_name: str) -> str:
+    cleaned = project_name.strip()
+    if not cleaned:
+        raise InvalidProjectNameError("Project name is required.")
+
+    slug = _NON_ALNUM.sub("-", cleaned).strip("-").lower()
+    slug = _MULTIPLE_DASHES.sub("-", slug)
+    if not slug:
+        raise InvalidProjectNameError("Project name must contain letters or numbers.")
+    return slug
+
+
+def normalize_package_name(project_name: str) -> str:
+    cleaned = project_name.strip()
+    if not cleaned:
+        raise InvalidProjectNameError("Project name is required.")
+
+    package_name = _NON_ALNUM.sub("_", cleaned).strip("_").lower()
+    package_name = _MULTIPLE_UNDERSCORES.sub("_", package_name)
+
+    if not package_name or not package_name.isidentifier() or keyword.iskeyword(package_name):
+        raise InvalidProjectNameError(
+            f"Project name '{project_name}' cannot be converted into a valid Python package name."
+        )
+
+    return package_name

project_initializer/pack.py

@@ -0,0 +1,186 @@
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from project_initializer.config import Database, ProjectConfig, ProjectType
+from project_initializer.errors import PackError
+
+
+@dataclass(frozen=True)
+class PackManifest:
+    name: str
+    dependencies: tuple[str, ...] = ()
+    dev_dependencies: tuple[str, ...] = ()
+    files: tuple[tuple[str, str], ...] = ()
+    make_targets: dict[str, str] = field(default_factory=dict)
+    env: dict[str, str] = field(default_factory=dict)
+    requires: tuple[str, ...] = ()
+    conflicts: tuple[str, ...] = ()
+
+
+def load_pack(pack_dir: Path) -> PackManifest:
+    manifest_path = pack_dir / "pack.yaml"
+    try:
+        raw = yaml.safe_load(manifest_path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise PackError(f"Pack at {pack_dir} is missing pack.yaml.") from exc
+    except yaml.YAMLError as exc:
+        raise PackError(f"Pack at {pack_dir} has invalid YAML: {exc}") from exc
+
+    if raw is None:
+        raw = {}
+    if not isinstance(raw, Mapping):
+        raise PackError(f"Pack at {pack_dir} manifest must be a mapping.")
+    if "name" not in raw:
+        raise PackError(f"Pack at {pack_dir} is missing required field 'name'.")
+
+    return _manifest_from_mapping(raw, pack_dir)
+
+
+def _manifest_from_mapping(raw: Mapping[str, Any], pack_dir: Path) -> PackManifest:
+    name = _require_non_empty_string(raw, "name", pack_dir)
+    files = _files_from_mapping(raw, pack_dir)
+
+    return PackManifest(
+        name=name,
+        dependencies=_string_tuple_field(raw, "dependencies", pack_dir),
+        dev_dependencies=_string_tuple_field(raw, "dev_dependencies", pack_dir),
+        files=files,
+        make_targets=_string_mapping_field(raw, "make_targets", pack_dir),
+        env=_string_mapping_field(raw, "env", pack_dir),
+        requires=_string_tuple_field(raw, "requires", pack_dir),
+        conflicts=_string_tuple_field(raw, "conflicts", pack_dir),
+    )
+
+
+def _require_non_empty_string(
+    raw: Mapping[str, Any], field_name: str, pack_dir: Path
+) -> str:
+    value = raw[field_name]
+    if not isinstance(value, str) or not value:
+        raise PackError(
+            f"Pack at {pack_dir} has invalid field '{field_name}'; expected a non-empty string."
+        )
+    return value
+
+
+def _string_tuple_field(
+    raw: Mapping[str, Any], field_name: str, pack_dir: Path
+) -> tuple[str, ...]:
+    value = raw.get(field_name, [])
+    if not isinstance(value, (list, tuple)):
+        raise PackError(f"Pack at {pack_dir} field '{field_name}' must be a list of strings.")
+    if not all(isinstance(item, str) for item in value):
+        raise PackError(f"Pack at {pack_dir} field '{field_name}' must be a list of strings.")
+    return tuple(value)
+
+
+def _string_mapping_field(
+    raw: Mapping[str, Any], field_name: str, pack_dir: Path
+) -> dict[str, str]:
+    value = raw.get(field_name, {})
+    if not isinstance(value, Mapping):
+        raise PackError(
+            f"Pack at {pack_dir} field '{field_name}' must be a mapping of strings to strings."
+        )
+    if not all(isinstance(key, str) and isinstance(item, str) for key, item in value.items()):
+        raise PackError(
+            f"Pack at {pack_dir} field '{field_name}' must be a mapping of strings to strings."
+        )
+    return dict(value)
+
+
+def _files_from_mapping(
+    raw: Mapping[str, Any], pack_dir: Path
+) -> tuple[tuple[str, str], ...]:
+    value = raw.get("files", [])
+    if not isinstance(value, (list, tuple)):
+        raise PackError(f"Pack at {pack_dir} field 'files' must be a list of file mappings.")
+
+    files = []
+    for file_entry in value:
+        if not isinstance(file_entry, Mapping):
+            raise PackError(f"Pack at {pack_dir} field 'files' must contain file mappings.")
+        source = file_entry.get("source")
+        destination = file_entry.get("destination")
+        if not isinstance(source, str) or not source:
+            raise PackError(f"Pack at {pack_dir} has a file entry without source and destination.")
+        if not isinstance(destination, str) or not destination:
+            raise PackError(f"Pack at {pack_dir} has a file entry without source and destination.")
+        files.append((str(source), str(destination)))
+
+    return tuple(files)
+
+
+def resolve_packs(
+    config: ProjectConfig,
+    *,
+    available_packs: dict[str, PackManifest] | None = None,
+    explicit_names: list[str] | None = None,
+) -> list[PackManifest]:
+    pack_map = _default_pack_manifest_map() if available_packs is None else available_packs
+    names = _pack_names_for_config(config) if explicit_names is None else explicit_names
+
+    selected = [_require_pack(pack_map, name) for name in names]
+    selected_names = {pack.name for pack in selected}
+
+    for pack in selected:
+        for required in pack.requires:
+            if required not in selected_names:
+                raise PackError(f"Pack '{pack.name}' requires pack '{required}'.")
+        for conflict in pack.conflicts:
+            if conflict in selected_names:
+                raise PackError(f"Pack '{pack.name}' conflicts with selected pack '{conflict}'.")
+
+    return selected
+
+
+def _require_pack(pack_map: dict[str, PackManifest], name: str) -> PackManifest:
+    try:
+        return pack_map[name]
+    except KeyError as exc:
+        raise PackError(f"Required pack '{name}' is not available.") from exc
+
+
+def _pack_names_for_config(config: ProjectConfig) -> list[str]:
+    names = ["common"]
+
+    if config.project_type is ProjectType.DJANGO:
+        names.append("django")
+    elif config.project_type is ProjectType.DJANGO_DRF:
+        names.extend(["django", "django_drf"])
+    elif config.project_type is ProjectType.FASTAPI:
+        names.append("fastapi")
+
+    if config.database is Database.SQLITE:
+        names.append("database_sqlite")
+    elif config.database is Database.POSTGRESQL:
+        names.append("database_postgres")
+
+    if config.project_type in {ProjectType.DJANGO, ProjectType.DJANGO_DRF} and (
+        config.database is not Database.NONE
+    ):
+        names.append("django_models")
+
+    if config.use_sqlalchemy and config.database is not Database.NONE:
+        names.append("orm_sqlalchemy")
+    if config.use_alembic and config.database is not Database.NONE:
+        names.append("migrations_alembic")
+    if config.tooling.use_pytest:
+        names.append("tooling_pytest")
+    if config.tooling.use_ruff:
+        names.append("tooling_ruff")
+    if config.tooling.use_docker:
+        names.append("docker")
+
+    return names
+
+
+def _default_pack_manifest_map() -> dict[str, PackManifest]:
+    from project_initializer.resources import builtin_pack_dirs
+
+    manifests = [load_pack(pack_dir) for pack_dir in builtin_pack_dirs()]
+    return {manifest.name: manifest for manifest in manifests}

project_initializer/packs/common/pack.yaml

@@ -0,0 +1,8 @@
+name: common
+files:
+  - source: README.md.j2
+    destination: README.md
+  - source: .gitignore.j2
+    destination: .gitignore
+make_targets:
+  migrate: "python -c \"print('No migrations configured')\""

project_initializer/packs/common/templates/.gitignore.j2

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.env
+db.sqlite3

project_initializer/packs/common/templates/README.md.j2

@@ -0,0 +1,27 @@
+# {{ project.project_name }}
+
+Generated with kraf.
+
+## Development
+
+```bash
+make venv
+make install
+make run
+```
+
+## Quality
+
+```bash
+make test
+make lint
+make format
+```
+{% if project.database.value != "none" %}
+
+## Database
+
+```bash
+make migrate
+```
+{% endif %}

project_initializer/packs/database_postgres/pack.yaml

@@ -0,0 +1,5 @@
+name: database_postgres
+dependencies:
+  - psycopg[binary]
+env:
+  DATABASE_URL: postgresql://postgres:postgres@localhost:5432/app

project_initializer/packs/database_sqlite/pack.yaml

@@ -0,0 +1,3 @@
+name: database_sqlite
+env:
+  DATABASE_URL: sqlite:///db.sqlite3

project_initializer/packs/django/pack.yaml

@@ -0,0 +1,22 @@
+name: django
+dependencies:
+  - django
+files:
+  - source: manage.py.j2
+    destination: manage.py
+  - source: project/__init__.py.j2
+    destination: "{{ project.package_name }}/__init__.py"
+  - source: project/settings.py.j2
+    destination: "{{ project.package_name }}/settings.py"
+  - source: project/urls.py.j2
+    destination: "{{ project.package_name }}/urls.py"
+  - source: project/wsgi.py.j2
+    destination: "{{ project.package_name }}/wsgi.py"
+  - source: project/asgi.py.j2
+    destination: "{{ project.package_name }}/asgi.py"
+make_targets:
+  run: "$(VENV_PYTHON) manage.py runserver"
+  migrate: "$(VENV_PYTHON) manage.py migrate"
+  makemigrations: "$(VENV_PYTHON) manage.py makemigrations"
+conflicts:
+  - fastapi

project_initializer/packs/django/templates/manage.py.j2

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+import os
+import sys
+
+
+def main() -> None:
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "{{ project.package_name }}.settings")
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

project_initializer/packs/django/templates/project/__init__.py.j2

@@ -0,0 +1 @@
+# Generated Django project package.

project_initializer/packs/django/templates/project/asgi.py.j2

@@ -0,0 +1,7 @@
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "{{ project.package_name }}.settings")
+
+application = get_asgi_application()