pygenkit 0.2.0__py3-none-any.whl

pygenkit/inspector/pyproject.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from pygenkit.models.inspection import BuildBackend
+
+BACKEND_MAP: dict[str, str] = {
+    "setuptools.build_meta": "setuptools",
+    "hatchling.build": "hatchling",
+    "poetry.core.masonry.api": "poetry",
+    "flit_core.buildapi": "flit",
+    "pdm.buildapi": "pdm",
+    "maturin": "maturin",
+    "mesonpy": "meson-python",
+    "scikit_build_core.build": "scikit-build-core",
+}
+
+
+def read_pyproject(root: str | Path) -> dict[str, Any]:
+    path = Path(root) / "pyproject.toml"
+    if not path.exists():
+        raise FileNotFoundError(f"pyproject.toml not found in {root}")
+    raw = path.read_bytes()
+    return tomllib.loads(raw.decode("utf-8"))
+
+
+def detect_build_backend(data: dict[str, Any]) -> BuildBackend | None:
+    build_system = data.get("build-system", {})
+    backend_path = build_system.get("build-backend", "")
+    requires = build_system.get("requires", [])
+
+    name = BACKEND_MAP.get(backend_path, backend_path.split(".")[0] if backend_path else "unknown")
+    if not backend_path:
+        return None
+
+    return BuildBackend(name=name, backend=backend_path, requires=requires)
+
+
+def _get_project_field(data: dict[str, Any], field: str) -> str | None:
+    project = data.get("project", {})
+    if not isinstance(project, dict):
+        return None
+    val = project.get(field)
+    return str(val) if val is not None else None
+
+
+def detect_project_name(data: dict[str, Any]) -> str | None:
+    return _get_project_field(data, "name")
+
+
+def detect_project_version(data: dict[str, Any]) -> str | None:
+    return _get_project_field(data, "version")
+
+
+def detect_python_requires(data: dict[str, Any]) -> str | None:
+    return _get_project_field(data, "requires-python")
+
+
+def detect_dependencies(data: dict[str, Any]) -> list[str]:
+    project = data.get("project", {})
+    if not isinstance(project, dict):
+        return []
+    deps = project.get("dependencies", [])
+    return [str(d) for d in deps] if isinstance(deps, list) else []
+
+
+def detect_test_deps(data: dict[str, Any]) -> list[str]:
+    optional = data.get("project", {}).get("optional-dependencies", {})
+    deps: list[str] = []
+    for group in optional.values():
+        deps.extend(group)
+    return deps

pygenkit/models/__init__.py

@@ -0,0 +1,25 @@
+from pygenkit.models.config import (
+    CIConfig,
+    DebianConfig,
+    DeployConfig,
+    DockerConfig,
+    GitHubConfig,
+    ProjectConfig,
+    PyGenKitConfig,
+    PyPIConfig,
+    ReleaseConfig,
+)
+from pygenkit.models.inspection import ProjectInspection
+
+__all__ = [
+    "PyGenKitConfig",
+    "ProjectConfig",
+    "CIConfig",
+    "ReleaseConfig",
+    "PyPIConfig",
+    "DebianConfig",
+    "GitHubConfig",
+    "DockerConfig",
+    "DeployConfig",
+    "ProjectInspection",
+]

pygenkit/models/config.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ProjectConfig:
+    name: str
+    version: str = "0.1.0"
+    extras: str = ""
+
+
+@dataclass
+class CIConfig:
+    python_versions: list[str] = field(default_factory=lambda: ["3.12"])
+    runner: str = "ubuntu-latest"
+    lint: bool = True
+    type_check: bool = True
+
+
+@dataclass
+class ReleaseConfig:
+    branch: str = "main"
+    tag_prefix: str = "v"
+    changelog: str = "CHANGELOG.md"
+
+
+@dataclass
+class PyPIConfig:
+    enabled: bool = True
+    environment: str = "pypi"
+    trusted_publishing: bool = True
+
+
+@dataclass
+class DebianConfig:
+    enabled: bool = True
+    email: str = ""
+    name: str = ""
+    owner: str = ""
+    ppa: str = "tools"
+    distributions: list[str] = field(default_factory=lambda: ["noble"])
+    revision: str = "1"
+
+
+@dataclass
+class GitHubConfig:
+    ci: bool = True
+    release: bool = True
+    publish_pypi: bool = True
+    publish_launchpad: bool = True
+
+
+@dataclass
+class DockerConfig:
+    enabled: bool = False
+    base_image: str = "3.12"
+    port: int = 8000
+    volumes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DeployConfig:
+    enabled: bool = False
+    fly: bool = True
+    heroku: bool = True
+    railway: bool = True
+    primary_region: str = "iad"
+    port: int = 8000
+    memory: str = "512mb"
+    cpu_kind: str = "shared"
+    cpus: int = 1
+
+
+@dataclass
+class PyGenKitConfig:
+    project: ProjectConfig
+    ci: CIConfig = field(default_factory=CIConfig)
+    release: ReleaseConfig = field(default_factory=ReleaseConfig)
+    pypi: PyPIConfig = field(default_factory=PyPIConfig)
+    debian: DebianConfig = field(default_factory=DebianConfig)
+    github: GitHubConfig = field(default_factory=GitHubConfig)
+    docker: DockerConfig = field(default_factory=DockerConfig)
+    deploy: DeployConfig = field(default_factory=DeployConfig)
+
+    @classmethod
+    def load(cls, path: str | Path) -> PyGenKitConfig:
+        path = Path(path)
+        if not path.exists():
+            raise FileNotFoundError(f"Config not found: {path}")
+
+        raw = path.read_bytes()
+        data = tomllib.loads(raw.decode("utf-8"))
+
+        return cls(
+            project=ProjectConfig(
+                name=data.get("project", {}).get("name", ""),
+                version=data.get("project", {}).get("version", "0.1.0"),
+                extras=data.get("project", {}).get("extras", ""),
+            ),
+            ci=CIConfig(
+                python_versions=data.get("ci", {}).get("python_versions", ["3.12"]),
+                runner=data.get("ci", {}).get("runner", "ubuntu-latest"),
+                lint=data.get("ci", {}).get("lint", True),
+                type_check=data.get("ci", {}).get("type_check", True),
+            ),
+            release=ReleaseConfig(
+                branch=data.get("release", {}).get("branch", "main"),
+                tag_prefix=data.get("release", {}).get("tag_prefix", "v"),
+                changelog=data.get("release", {}).get("changelog", "CHANGELOG.md"),
+            ),
+            pypi=PyPIConfig(
+                enabled=data.get("pypi", {}).get("enabled", True),
+                environment=data.get("pypi", {}).get("environment", "pypi"),
+                trusted_publishing=data.get("pypi", {}).get("trusted_publishing", True),
+            ),
+            debian=DebianConfig(
+                enabled=data.get("debian", {}).get("enabled", True),
+                email=data.get("debian", {}).get("email", ""),
+                name=data.get("debian", {}).get("name", ""),
+                owner=data.get("debian", {}).get("owner", ""),
+                ppa=data.get("debian", {}).get("ppa", "tools"),
+                distributions=data.get("debian", {}).get("distributions", ["noble"]),
+                revision=data.get("debian", {}).get("revision", "1"),
+            ),
+            github=GitHubConfig(
+                ci=data.get("github", {}).get("ci", True),
+                release=data.get("github", {}).get("release", True),
+                publish_pypi=data.get("github", {}).get("publish_pypi", True),
+                publish_launchpad=data.get("github", {}).get("publish_launchpad", True),
+            ),
+            docker=DockerConfig(
+                enabled=data.get("docker", {}).get("enabled", False),
+                base_image=data.get("docker", {}).get("base_image", "3.12"),
+                port=data.get("docker", {}).get("port", 8000),
+                volumes=data.get("docker", {}).get("volumes", []),
+            ),
+            deploy=DeployConfig(
+                enabled=data.get("deploy", {}).get("enabled", False),
+                fly=data.get("deploy", {}).get("fly", True),
+                heroku=data.get("deploy", {}).get("heroku", True),
+                railway=data.get("deploy", {}).get("railway", True),
+                primary_region=data.get("deploy", {}).get("primary_region", "iad"),
+                port=data.get("deploy", {}).get("port", 8000),
+                memory=data.get("deploy", {}).get("memory", "512mb"),
+                cpu_kind=data.get("deploy", {}).get("cpu_kind", "shared"),
+                cpus=data.get("deploy", {}).get("cpus", 1),
+            ),
+        )
+
+    @classmethod
+    def generate_default(cls, name: str) -> str:
+        return f"""[project]
+name = "{name}"
+version = "0.1.0"
+extras = ""
+
+[ci]
+python_versions = ["3.12", "3.13"]
+runner = "ubuntu-latest"
+lint = true
+type_check = true
+
+[release]
+branch = "main"
+tag_prefix = "v"
+changelog = "CHANGELOG.md"
+
+[pypi]
+enabled = true
+environment = "pypi"
+trusted_publishing = true
+
+[debian]
+enabled = true
+email = ""
+name = ""
+owner = ""
+ppa = "tools"
+distributions = ["noble"]
+revision = "1"
+
+[github]
+ci = true
+release = true
+publish_pypi = true
+publish_launchpad = true
+
+[docker]
+enabled = false
+base_image = "3.12"
+port = 8000
+volumes = []
+
+[deploy]
+enabled = false
+fly = true
+heroku = true
+railway = true
+primary_region = "iad"
+port = 8000
+memory = "512mb"
+cpu_kind = "shared"
+cpus = 1
+"""
+
+    def save(self, path: str | Path) -> None:
+        path = Path(path)
+        path.write_text(self._to_toml(), encoding="utf-8")
+
+    def _to_toml(self) -> str:
+        return f"""[project]
+name = "{self.project.name}"
+version = "{self.project.version}"
+extras = "{self.project.extras}"
+
+[ci]
+python_versions = {self.ci.python_versions}
+runner = "{self.ci.runner}"
+lint = {str(self.ci.lint).lower()}
+type_check = {str(self.ci.type_check).lower()}
+
+[release]
+branch = "{self.release.branch}"
+tag_prefix = "{self.release.tag_prefix}"
+changelog = "{self.release.changelog}"
+
+[pypi]
+enabled = {str(self.pypi.enabled).lower()}
+environment = "{self.pypi.environment}"
+trusted_publishing = {str(self.pypi.trusted_publishing).lower()}
+
+[debian]
+enabled = {str(self.debian.enabled).lower()}
+email = "{self.debian.email}"
+name = "{self.debian.name}"
+owner = "{self.debian.owner}"
+ppa = "{self.debian.ppa}"
+distributions = {self.debian.distributions}
+revision = "{self.debian.revision}"
+
+[github]
+ci = {str(self.github.ci).lower()}
+release = {str(self.github.release).lower()}
+publish_pypi = {str(self.github.publish_pypi).lower()}
+publish_launchpad = {str(self.github.publish_launchpad).lower()}
+
+[docker]
+enabled = {str(self.docker.enabled).lower()}
+base_image = "{self.docker.base_image}"
+port = {self.docker.port}
+volumes = {self.docker.volumes}
+
+[deploy]
+enabled = {str(self.deploy.enabled).lower()}
+fly = {str(self.deploy.fly).lower()}
+heroku = {str(self.deploy.heroku).lower()}
+railway = {str(self.deploy.railway).lower()}
+primary_region = "{self.deploy.primary_region}"
+port = {self.deploy.port}
+memory = "{self.deploy.memory}"
+cpu_kind = "{self.deploy.cpu_kind}"
+cpus = {self.deploy.cpus}
+"""

pygenkit/models/health.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CategoryScore:
+    name: str
+    weight: float  # contribution to total (0.0 to 1.0, sum = 1.0)
+    score: float = 0.0  # 0.0 to 1.0
+    passed: int = 0
+    total: int = 0
+    details: list[str] = field(default_factory=list)
+    issues: list[str] = field(default_factory=list)
+
+
+@dataclass
+class HealthReport:
+    score: int  # 0-100
+    categories: dict[str, CategoryScore] = field(default_factory=dict)
+    issues: list[str] = field(default_factory=list)
+    suggestions: list[str] = field(default_factory=list)

pygenkit/models/inspection.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class BuildBackend:
+    name: str
+    backend: str  # setuptools, hatchling, poetry, etc.
+    requires: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DebianInspection:
+    present: bool = False
+    has_control: bool = False
+    has_changelog: bool = False
+    version_in_changelog: str | None = None
+    issues: list[str] = field(default_factory=list)
+
+
+@dataclass
+class WorkflowInspection:
+    has_ci: bool = False
+    has_pypi_publish: bool = False
+    has_launchpad: bool = False
+    files: list[str] = field(default_factory=list)
+
+
+@dataclass
+class VersionInspection:
+    pyproject_version: str | None = None
+    init_version: str | None = None
+    changelog_version: str | None = None
+    git_tags: list[str] = field(default_factory=list)
+    consistent: bool = False
+    issues: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ProjectInspection:
+    name: str | None = None
+    version: str | None = None
+    python_requires: str | None = None
+    module: str | None = None
+    root: str = ""
+    build_backend: BuildBackend | None = None
+    has_tests: bool = False
+    has_license: bool = False
+    license_type: str | None = None
+    has_debian: DebianInspection = field(default_factory=DebianInspection)
+    has_workflows: WorkflowInspection = field(default_factory=WorkflowInspection)
+    versions: VersionInspection = field(default_factory=VersionInspection)
+    github_remote: str | None = None
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)

pygenkit/render/__init__.py

@@ -0,0 +1,3 @@
+from pygenkit.render.engine import RenderEngine
+
+__all__ = ["RenderEngine"]

pygenkit/render/engine.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from pygenkit.utils.filters import TemplateFilters
+
+
+class RenderEngine:
+    def __init__(self, templates_dir: str | Path) -> None:
+        self.templates_dir = Path(templates_dir)
+        self._env = Environment(
+            loader=FileSystemLoader(str(self.templates_dir)),
+            undefined=StrictUndefined,
+            trim_blocks=True,
+            lstrip_blocks=True,
+            keep_trailing_newline=True,
+        )
+        self._env.filters.update(TemplateFilters.get_filters())
+
+    def render_string(self, template: str, context: dict[str, Any]) -> str:
+        t = self._env.from_string(template)
+        return t.render(**context)
+
+    def render_file(self, template_path: str, context: dict[str, Any]) -> str:
+        t = self._env.get_template(template_path)
+        return t.render(**context)
+
+    def render_to_file(
+        self,
+        template_path: str,
+        output_path: str | Path,
+        context: dict[str, Any],
+    ) -> Path:
+        content = self.render_file(template_path, context)
+        out = Path(output_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(content, encoding="utf-8")
+        return out

pygenkit/templates/deploy/Procfile.j2

@@ -0,0 +1 @@
+web: {{ project.name }}

pygenkit/templates/deploy/fly.toml.j2

@@ -0,0 +1,14 @@
+app = "{{ project.name }}"
+primary_region = "{{ deploy.primary_region }}"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[http_service]
+  internal_port = {{ deploy.port }}
+  force_https = true
+
+[[vm]]
+  memory = "{{ deploy.memory }}"
+  cpu_kind = "{{ deploy.cpu_kind }}"
+  cpus = {{ deploy.cpus }}

pygenkit/templates/deploy/railway.json.j2

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS",
+    "buildCommand": "pip install build && python -m build --wheel"
+  },
+  "deploy": {
+    "numReplicas": 1,
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}

pygenkit/templates/docker/Dockerfile.j2

@@ -0,0 +1,15 @@
+FROM python:{{ docker.base_image }}-slim AS builder
+
+WORKDIR /build
+COPY . .
+RUN pip install build && python -m build --wheel
+
+FROM python:{{ docker.base_image }}-slim
+
+WORKDIR /app
+COPY --from=builder /build/dist/*.whl /tmp/
+RUN pip install /tmp/*.whl && rm /tmp/*.whl
+
+EXPOSE {{ docker.port }}
+
+CMD ["{{ project.name }}"]

pygenkit/templates/docker/docker-compose.yml.j2

@@ -0,0 +1,17 @@
+version: "3.9"
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "{{ docker.port }}:{{ docker.port }}"
+    environment:
+      - PYTHONUNBUFFERED=1
+{% if docker.volumes %}
+    volumes:
+{% for vol in docker.volumes %}
+      - {{ vol }}
+{% endfor %}
+{% endif %}

pygenkit/templates/github/workflows/ci.yml.j2

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches: [{{ release.branch }}]
+  pull_request:
+    branches: [{{ release.branch }}]
+
+jobs:
+  test:
+    runs-on: {{ ci.runner }}
+    strategy:
+      matrix:
+        python-version: {{ ci.python_versions }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: {% raw %}${{ matrix.python-version }}{% endraw %}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .{% if project.extras %}["{{ project.extras }}"]{% endif %}
+{% if ci.lint %}
+      - name: Lint
+        run: pip install ruff && ruff check .
+{% endif %}
+{% if ci.type_check %}
+      - name: Type check
+        run: pip install mypy && mypy src/
+{% endif %}
+      - name: Test
+        run: pip install pytest && pytest

pygenkit/templates/github/workflows/publish-launchpad.yml.j2

@@ -0,0 +1,37 @@
+name: Publish to Launchpad
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  launchpad:
+    runs-on: {{ ci.runner }}
+    environment: launchpad
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "{{ ci.python_versions[0] }}"
+      - name: Install build deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y devscripts debhelper dput
+      - name: Import GPG signing key
+        env:
+          GPG_PRIVATE_KEY: {% raw %}${{ secrets.GPG_PRIVATE_KEY }}{% endraw %}
+          GPG_PASSPHRASE: {% raw %}${{ secrets.GPG_PASSPHRASE }}{% endraw %}
+          GPG_KEY_ID: {% raw %}${{ secrets.GPG_KEY_ID }}{% endraw %}
+        run: |
+          printf '%s' "$GPG_PRIVATE_KEY" | gpg --batch --import
+          printf '%s' "$GPG_PASSPHRASE" | gpg \
+            --batch --yes --pinentry-mode loopback --passphrase-fd 0 \
+            --local-user "$GPG_KEY_ID" --sign /dev/null
+      - name: Build source package
+        env:
+          GPG_KEY_ID: {% raw %}${{ secrets.GPG_KEY_ID }}{% endraw %}
+        run: |
+          debuild -S -sa -d -k"$GPG_KEY_ID"
+      - name: Upload to Launchpad
+        run: |
+          dput ppa:{{ debian.owner }}/{{ debian.ppa }} ../*.changes

pygenkit/templates/github/workflows/publish-pypi.yml.j2

@@ -0,0 +1,32 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: {{ ci.runner }}
+    environment: {{ pypi.environment }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "{{ ci.python_versions[0] }}"
+      - name: Build
+        run: |
+          pip install build
+          python -m build
+{% if pypi.trusted_publishing %}
+      - name: Publish (trusted)
+        uses: pypa/gh-action-pypi-publish@release/v1
+{% else %}
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: {% raw %}${{ secrets.PYPI_TOKEN }}{% endraw %}
+{% endif %}

pygenkit/templates/github/workflows/release.yml.j2

@@ -0,0 +1,28 @@
+name: Release
+
+on:
+  push:
+    tags: ["{{ release.tag_prefix }}*"]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: {{ ci.runner }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "{{ ci.python_versions[0] }}"
+      - name: Build
+        run: |
+          pip install build
+          python -m build
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          files: dist/*