pygenkit 0.2.0__py3-none-any.whl

pygenkit/health/checks.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pygenkit.inspector import debian as debian_inspector
+from pygenkit.inspector import detect as detect_inspector
+from pygenkit.inspector import git as git_inspector
+from pygenkit.inspector.pyproject import (
+    detect_project_name,
+    detect_project_version,
+)
+from pygenkit.models.health import CategoryScore
+
+
+def check_versioning(root: Path, pyproject_data: dict[str, Any] | None) -> CategoryScore:
+    score = CategoryScore(name="Versioning", weight=0.15)
+    pyproject_ver = None
+
+    if pyproject_data:
+        pyproject_ver = detect_project_version(pyproject_data)
+        if pyproject_ver:
+            score.passed += 1
+            score.details.append(f"pyproject.toml: {pyproject_ver}")
+        else:
+            score.issues.append("No version in pyproject.toml")
+    score.total += 1
+
+    module = _detect_module(root, pyproject_data)
+    init_ver = detect_inspector.detect_version_in_init(root, module)
+    if init_ver:
+        score.passed += 1
+        score.details.append(f"__init__.py: {init_ver}")
+    else:
+        score.issues.append("No __version__ in module __init__.py")
+    score.total += 1
+
+    debian_info = debian_inspector.inspect_debian(root)
+    if debian_info.present and debian_info.version_in_changelog:
+        score.passed += 1
+        score.details.append(f"debian/changelog: {debian_info.version_in_changelog}")
+    elif debian_info.present:
+        score.issues.append("debian/changelog has no parseable version")
+    score.total += 1
+
+    git_tags = git_inspector.detect_git_tags(root)
+    if git_tags:
+        score.passed += 1
+        score.details.append(f"{len(git_tags)} git tag(s)")
+    else:
+        score.issues.append("No git tags")
+    score.total += 1
+
+    consistent = _check_consistent(pyproject_ver, init_ver)
+    if consistent:
+        score.passed += 1
+        score.details.append("Versions are consistent")
+    else:
+        score.issues.append("Versions are inconsistent")
+    score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def check_testing(root: Path) -> CategoryScore:
+    score = CategoryScore(name="Testing", weight=0.15)
+
+    has_tests = detect_inspector.detect_tests(root)
+    if has_tests:
+        score.passed += 1
+        score.details.append("Tests directory found")
+    else:
+        score.issues.append("No tests directory")
+    score.total += 1
+
+    if has_tests:
+        test_dir = root / "tests"
+        if test_dir.is_dir():
+            py_files = list(test_dir.rglob("test_*.py"))
+            score.details.append(f"{len(py_files)} test file(s)")
+            if py_files:
+                score.passed += 1
+            else:
+                score.issues.append("No test_*.py files in tests/")
+        score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def check_documentation(root: Path) -> CategoryScore:
+    score = CategoryScore(name="Documentation", weight=0.15)
+
+    readme = detect_inspector.detect_readme(root)
+    if readme:
+        score.passed += 1
+        score.details.append(f"README: {readme.name}")
+    else:
+        score.issues.append("No README file")
+    score.total += 1
+
+    changelog = root / "CHANGELOG.md"
+    if changelog.exists():
+        score.passed += 1
+        score.details.append("CHANGELOG.md present")
+    else:
+        score.issues.append("No CHANGELOG.md")
+    score.total += 1
+
+    contributing = root / "CONTRIBUTING.md"
+    if contributing.exists():
+        score.passed += 1
+        score.details.append("CONTRIBUTING.md present")
+    score.total += 1
+
+    license_result = detect_inspector.detect_license(root)
+    if license_result:
+        score.passed += 1
+        score.details.append(f"License: {license_result}")
+    else:
+        score.issues.append("No license file")
+    score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def check_cicd(root: Path) -> CategoryScore:
+    score = CategoryScore(name="CICD", weight=0.20)
+
+    wf_dir = root / ".github" / "workflows"
+    if wf_dir.is_dir():
+        wf_files = list(wf_dir.glob("*.yml"))
+        score.details.append(f"{len(wf_files)} workflow file(s)")
+        if wf_files:
+            score.passed += 1
+        score.total += 1
+
+        has_ci = any("ci" in f.name.lower() for f in wf_files)
+        has_release = any("release" in f.name.lower() for f in wf_files)
+        has_pypi = any("pypi" in f.name.lower() for f in wf_files)
+
+        if has_ci:
+            score.passed += 1
+            score.details.append("CI workflow present")
+        else:
+            score.issues.append("No CI workflow")
+        score.total += 1
+
+        if has_release:
+            score.passed += 1
+            score.details.append("Release workflow present")
+        else:
+            score.issues.append("No release workflow")
+        score.total += 1
+
+        if has_pypi:
+            score.passed += 1
+            score.details.append("PyPI publish workflow present")
+        else:
+            score.issues.append("No PyPI publish workflow")
+        score.total += 1
+    else:
+        score.issues.append("No GitHub Actions workflows")
+        score.total += 3  # ci, release, pypi
+
+    dockerfile = root / "Dockerfile"
+    if dockerfile.exists():
+        score.passed += 1
+        score.details.append("Dockerfile present")
+    score.total += 1
+
+    deploy_files = ["fly.toml", "Procfile", "railway.json", "heroku.yml"]
+    deploy_count = sum(1 for f in deploy_files if (root / f).exists())
+    if deploy_count > 0:
+        score.passed += 1
+        score.details.append(f"{deploy_count} deploy config(s) present")
+    score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def check_security(root: Path) -> CategoryScore:
+    score = CategoryScore(name="Security", weight=0.15)
+
+    license_type = detect_inspector.detect_license(root)
+    if license_type:
+        score.passed += 1
+        score.details.append(f"License: {license_type}")
+    else:
+        score.issues.append("No license")
+    score.total += 1
+
+    git_dir = root / ".git"
+    if git_dir.is_dir():
+        score.passed += 1
+    else:
+        score.issues.append("Not a git repository")
+    score.total += 1
+
+    github_remote = git_inspector.detect_github_remote(root)
+    if github_remote:
+        score.passed += 1
+    else:
+        score.issues.append("No GitHub remote configured")
+    score.total += 1
+
+    wf_dir = root / ".github" / "workflows"
+    has_permissions = False
+    if wf_dir.is_dir():
+        for f in wf_dir.glob("*.yml"):
+            content = f.read_text(encoding="utf-8", errors="replace")
+            if "permissions:" in content:
+                has_permissions = True
+                break
+
+    if has_permissions or not wf_dir.is_dir():
+        score.passed += 1
+    else:
+        score.issues.append("Workflows missing permissions block")
+    score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def check_packaging(root: Path, pyproject_data: dict[str, Any] | None) -> CategoryScore:
+    score = CategoryScore(name="Packaging", weight=0.10)
+
+    if pyproject_data:
+        score.passed += 1
+        score.details.append("pyproject.toml present")
+    else:
+        score.issues.append("No pyproject.toml")
+    score.total += 1
+
+    if pyproject_data:
+        pkg_data = pyproject_data.get("project", {})
+        if pkg_data.get("name"):
+            score.passed += 1
+        else:
+            score.issues.append("pyproject.toml missing project name")
+        score.total += 1
+
+        if pkg_data.get("version"):
+            score.passed += 1
+        else:
+            score.issues.append("pyproject.toml missing version")
+        score.total += 1
+
+        if pkg_data.get("description"):
+            score.passed += 1
+        else:
+            score.issues.append("pyproject.toml missing description")
+        score.total += 1
+
+    src_dir = root / "src"
+    if src_dir.is_dir():
+        score.passed += 1
+        score.details.append("src/ layout detected")
+    else:
+        score.issues.append("Not using src/ layout (recommended)")
+    score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def check_structure(root: Path) -> CategoryScore:
+    score = CategoryScore(name="Structure", weight=0.10)
+
+    gitignore = root / ".gitignore"
+    if gitignore.exists():
+        score.passed += 1
+    else:
+        score.issues.append("No .gitignore")
+    score.total += 1
+
+    editorconfig = root / ".editorconfig"
+    if editorconfig.exists():
+        score.passed += 1
+    score.total += 1
+
+    ruff_toml = root / "ruff.toml"
+    pyproject_toml = root / "pyproject.toml"
+    ruff_configured = False
+    if ruff_toml.exists():
+        ruff_configured = True
+    elif pyproject_toml.exists():
+        data = _try_read_pyproject(pyproject_toml)
+        if data and "tool" in data and "ruff" in data["tool"]:
+            ruff_configured = True
+    if ruff_configured:
+        score.passed += 1
+        score.details.append("Ruff configured")
+    else:
+        score.issues.append("Ruff not configured")
+    score.total += 1
+
+    mypy_configured = False
+    mypy_ini = root / "mypy.ini"
+    if mypy_ini.exists():
+        mypy_configured = True
+    elif pyproject_toml.exists():
+        data = _try_read_pyproject(pyproject_toml)
+        if data and "tool" in data and "mypy" in data["tool"]:
+            mypy_configured = True
+    if mypy_configured:
+        score.passed += 1
+        score.details.append("Mypy configured")
+    else:
+        score.issues.append("Mypy not configured")
+    score.total += 1
+
+    precommit = root / ".pre-commit-config.yaml"
+    if precommit.exists():
+        score.passed += 1
+        score.details.append("pre-commit configured")
+    score.total += 1
+
+    score.score = score.passed / score.total if score.total > 0 else 0.0
+    return score
+
+
+def _detect_module(root: Path, pyproject_data: dict[str, Any] | None) -> str | None:
+    name = detect_project_name(pyproject_data) if pyproject_data else None
+    return detect_inspector.detect_module(root, name)
+
+
+def _check_consistent(pyproject_ver: str | None, init_ver: str | None) -> bool:
+    if pyproject_ver and init_ver:
+        return pyproject_ver == init_ver
+    return bool(pyproject_ver or init_ver)
+
+
+def _try_read_pyproject(path: Path) -> dict[str, Any] | None:
+    try:
+        import tomllib
+        return tomllib.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None

pygenkit/inspector/__init__.py

@@ -0,0 +1,3 @@
+from pygenkit.inspector.api import inspect_project
+
+__all__ = ["inspect_project"]

pygenkit/inspector/api.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pygenkit.inspector import debian as debian_inspector
+from pygenkit.inspector import detect as detect_inspector
+from pygenkit.inspector import git as git_inspector
+from pygenkit.inspector.pyproject import (
+    detect_build_backend,
+    detect_project_name,
+    detect_project_version,
+    detect_python_requires,
+    read_pyproject,
+)
+from pygenkit.models.inspection import (
+    DebianInspection,
+    ProjectInspection,
+    VersionInspection,
+    WorkflowInspection,
+)
+
+
+def inspect_project(root: str | Path = ".") -> ProjectInspection:
+    root = Path(root).resolve()
+    result = ProjectInspection(root=str(root))
+
+    try:
+        data = read_pyproject(root)
+    except FileNotFoundError:
+        result.errors.append("pyproject.toml not found")
+        return result
+    except Exception as exc:
+        result.errors.append(f"Failed to parse pyproject.toml: {exc}")
+        return result
+
+    result.name = detect_project_name(data)
+    result.version = detect_project_version(data)
+    result.python_requires = detect_python_requires(data)
+    result.build_backend = detect_build_backend(data)
+
+    if result.name:
+        result.module = detect_inspector.detect_module(root, result.name)
+    else:
+        result.module = detect_inspector.detect_module(root)
+
+    result.has_tests = detect_inspector.detect_tests(root)
+    result.license_type = detect_inspector.detect_license(root)
+    result.has_license = result.license_type is not None
+
+    init_ver = detect_inspector.detect_version_in_init(root, result.module)
+    pyproject_ver = result.version
+    debian_info = debian_inspector.inspect_debian(root)
+    result.has_debian = debian_info
+
+    github_remote = git_inspector.detect_github_remote(root)
+    result.github_remote = github_remote
+    git_tags = git_inspector.detect_git_tags(root)
+
+    workflows = _inspect_workflows(root)
+    result.has_workflows = workflows
+
+    result.versions = VersionInspection(
+        pyproject_version=pyproject_ver,
+        init_version=init_ver,
+        changelog_version=debian_info.version_in_changelog,
+        git_tags=git_tags,
+        consistent=_check_version_consistency(
+            pyproject_ver, init_ver, debian_info.version_in_changelog, git_tags
+        ),
+        issues=_collect_version_issues(
+            pyproject_ver, init_ver, debian_info.version_in_changelog, git_tags
+        ),
+    )
+
+    result.warnings = _collect_warnings(result, debian_info)
+
+    return result
+
+
+def _inspect_workflows(root: Path) -> WorkflowInspection:
+    wf = WorkflowInspection()
+    wf_dir = root / ".github" / "workflows"
+    if not wf_dir.is_dir():
+        return wf
+
+    for f in wf_dir.glob("*.yml"):
+        wf.files.append(f.name)
+        content = f.read_text(encoding="utf-8", errors="replace")
+        if "pypi" in content.lower() or "publish" in content.lower():
+            wf.has_pypi_publish = True
+        if "launchpad" in content.lower() or "ppa" in content.lower():
+            wf.has_launchpad = True
+        if "test" in content.lower() or "lint" in content.lower():
+            wf.has_ci = True
+
+    return wf
+
+
+def _check_version_consistency(
+    pyproject_ver: str | None,
+    init_ver: str | None,
+    changelog_ver: str | None,
+    git_tags: list[str],
+) -> bool:
+    versions = [v for v in [pyproject_ver, init_ver, changelog_ver] if v]
+    if not versions:
+        return True
+    if len(set(versions)) > 1:
+        return False
+    latest_tag = _latest_tag(git_tags)
+    if latest_tag and pyproject_ver and latest_tag != pyproject_ver:
+        return bool(not git_tags)
+    return True
+
+
+def _latest_tag(tags: list[str]) -> str | None:
+    for t in tags:
+        if t.startswith("v"):
+            return t.lstrip("v")
+    return tags[0] if tags else None
+
+
+def _collect_version_issues(
+    pyproject_ver: str | None,
+    init_ver: str | None,
+    changelog_ver: str | None,
+    git_tags: list[str],
+) -> list[str]:
+    issues: list[str] = []
+    if pyproject_ver and init_ver and pyproject_ver != init_ver:
+        issues.append(f"pyproject.toml version ({pyproject_ver}) != __init__.py ({init_ver})")
+    if pyproject_ver and changelog_ver and pyproject_ver != changelog_ver:
+        issues.append(
+            f"pyproject.toml ({pyproject_ver}) != debian/changelog ({changelog_ver})"
+        )
+    latest = _latest_tag(git_tags)
+    if latest and pyproject_ver and latest != pyproject_ver:
+        issues.append(f"latest git tag (v{latest}) != pyproject.toml version ({pyproject_ver})")
+    return issues
+
+
+def _collect_warnings(result: ProjectInspection, debian_info: DebianInspection) -> list[str]:
+    warnings: list[str] = []
+    if not result.has_tests:
+        warnings.append("No tests directory found")
+    if not result.has_license:
+        warnings.append("No license file found")
+    if not result.build_backend:
+        warnings.append("No build backend detected in pyproject.toml")
+    if not result.github_remote:
+        warnings.append("No GitHub remote configured")
+    if result.has_debian.present and debian_info.issues:
+        warnings.extend(f"Debian: {i}" for i in debian_info.issues)
+    return warnings

pygenkit/inspector/debian.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pygenkit.models.inspection import DebianInspection
+
+
+def inspect_debian(root: str | Path) -> DebianInspection:
+    debian_dir = Path(root) / "debian"
+    result = DebianInspection(present=debian_dir.is_dir())
+
+    if not result.present:
+        return result
+
+    control = debian_dir / "control"
+    changelog = debian_dir / "changelog"
+
+    result.has_control = control.exists()
+    result.has_changelog = changelog.exists()
+
+    if result.has_changelog:
+        ver = _parse_changelog_version(changelog)
+        result.version_in_changelog = ver
+
+    issues = _check_issues(debian_dir, result)
+    result.issues = issues
+
+    return result
+
+
+def _parse_changelog_version(path: Path) -> str | None:
+    try:
+        first_line = path.read_text(encoding="utf-8").split("\n")[0]
+        if "(" in first_line and ")" in first_line:
+            return first_line.split("(")[1].split(")")[0].split("-")[0]
+    except (IndexError, OSError):
+        pass
+    return None
+
+
+def _check_issues(debian_dir: Path, result: DebianInspection) -> list[str]:
+    issues: list[str] = []
+    if not result.has_control:
+        issues.append("debian/control is missing")
+    if not result.has_changelog:
+        issues.append("debian/changelog is missing")
+    if result.present and not (debian_dir / "rules").exists():
+        issues.append("debian/rules is missing (dh_make?)")
+    if result.present and not (debian_dir / "source" / "format").exists():
+        issues.append("debian/source/format is missing (use '3.0 (quilt)')")
+    return issues

pygenkit/inspector/detect.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+def detect_module(root: str | Path, project_name: str | None = None) -> str | None:
+    root = Path(root)
+    src_dir = root / "src"
+    if src_dir.is_dir():
+        candidates = sorted(
+            d for d in src_dir.iterdir()
+            if d.is_dir() and not d.name.startswith("_")
+        )
+        if candidates:
+            return candidates[0].name
+
+    top_dirs = sorted(d for d in root.iterdir() if d.is_dir() and not d.name.startswith("_"))
+    python_dirs = [d for d in top_dirs if (d / "__init__.py").exists()]
+    if python_dirs:
+        return python_dirs[0].name
+
+    if project_name:
+        candidate = project_name.replace("-", "_")
+        if (src_dir / candidate).is_dir():
+            return candidate
+
+    return None
+
+
+def detect_tests(root: str | Path) -> bool:
+    root = Path(root)
+    if (root / "tests").is_dir():
+        return True
+    test_files = list(root.glob("test_*.py")) + list(root.glob("*test*.py"))
+    return len(test_files) > 0
+
+
+def detect_license(root: str | Path) -> str | None:
+    root = Path(root)
+    for name in ("LICENSE", "LICENSE.txt", "LICENSE.md", "COPYING"):
+        path = root / name
+        if path.exists():
+            content = path.read_text(encoding="utf-8", errors="replace")
+            return _classify_license(content)
+    return None
+
+
+def _classify_license(content: str) -> str | None:
+    if "MIT" in content and "Permission is hereby granted" in content:
+        return "MIT"
+    if "Apache License" in content and "Version 2.0" in content:
+        return "Apache-2.0"
+    if "GNU GENERAL PUBLIC LICENSE" in content and "Version 3" in content:
+        return "GPL-3.0"
+    if "GNU GENERAL PUBLIC LICENSE" in content and "Version 2" in content:
+        return "GPL-2.0"
+    if "BSD" in content:
+        return "BSD"
+    if "Mozilla Public License" in content:
+        return "MPL-2.0"
+    return "custom"
+
+
+def detect_version_in_init(root: str | Path, module: str | None = None) -> str | None:
+    if not module:
+        return None
+    for base in (Path(root) / "src", Path(root)):
+        init = base / module / "__init__.py"
+        if init.exists():
+            for line in init.read_text(encoding="utf-8").split("\n"):
+                m = re.match(r'__version__\s*=\s*["\']([^"\']+)["\']', line)
+                if m:
+                    return m.group(1)
+    return None
+
+
+def detect_readme(root: str | Path) -> Path | None:
+    root = Path(root)
+    for name in ("README.md", "README.rst", "README.txt", "README"):
+        path = root / name
+        if path.exists():
+            return path
+    return None

pygenkit/inspector/git.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def detect_github_remote(root: str | Path) -> str | None:
+    try:
+        r = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            capture_output=True, text=True, timeout=10,
+            cwd=str(root),
+        )
+        if r.returncode != 0:
+            return None
+        url = r.stdout.strip()
+        if "github.com" in url:
+            return url
+        return url
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+
+
+def detect_git_tags(root: str | Path) -> list[str]:
+    try:
+        r = subprocess.run(
+            ["git", "tag", "--sort=-version:refname"],
+            capture_output=True, text=True, timeout=10,
+            cwd=str(root),
+        )
+        if r.returncode != 0:
+            return []
+        return [t.strip() for t in r.stdout.strip().split("\n") if t.strip()]
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return []
+
+
+def extract_github_owner_repo(url: str) -> tuple[str, str] | None:
+    if "github.com" not in url:
+        return None
+    parts = url.rstrip("/").replace(".git", "").split("/")
+    if len(parts) >= 2:
+        return (parts[-2], parts[-1])
+    return None
+
+
+def is_git_repo(root: str | Path) -> bool:
+    try:
+        r = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            capture_output=True, timeout=5, cwd=str(root),
+        )
+        return r.returncode == 0
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False