afterpython 0.0.1.dev2__py3-none-any.whl → 0.1.0.dev4__py3-none-any.whl

afterpython/pcu.py

@@ -0,0 +1,164 @@
+"""
+pcu = "pip check updates", similar to ncu (npm check updates in Node.js)
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, TypedDict, NamedTuple, TypeAlias
+
+if TYPE_CHECKING:
+    from tomlkit.toml_document import TOMLDocument
+
+import asyncio
+
+from packaging.requirements import Requirement
+
+from afterpython.version import Version
+
+
+class Dependency(NamedTuple):
+    requirement: Requirement
+    min_version: Version | None
+    max_version: Version | None = None
+    latest_version: Version | None = None
+
+
+DependencyName: TypeAlias = str
+ExtrasName: TypeAlias = str
+GroupName: TypeAlias = str
+FakeCategoryName: TypeAlias = str
+Dependencies = TypedDict(
+    "Dependencies",
+    {
+        "dependencies": dict[FakeCategoryName, list[Dependency]],
+        "optional-dependencies": dict[ExtrasName, list[Dependency]],
+        "dependency-groups": dict[GroupName, list[Dependency]],
+        "build-system": dict[str, list[Dependency]],
+    },
+)
+
+
+def parse_min_max_versions_from_requirement(
+    req: Requirement,
+) -> dict[str, Version | None]:
+    min_ver: Version | None = None
+    max_ver: Version | None = None
+    if req.specifier:
+        # req.specifier is like ">=8.3.0" or ">=1.0,<2.0"
+        versions = sorted(Version(spec.version) for spec in req.specifier)
+        if len(versions) == 1:
+            min_ver = versions[0]
+        else:
+            min_ver, max_ver = versions[0], versions[-1]
+    return {
+        "min_version": min_ver,
+        "max_version": max_ver,
+    }
+
+
+async def get_latest_versions(
+    requirements: list[Requirement],
+) -> dict[str, Version | None]:
+    """Get latest versions for a list of dependencies from PyPI."""
+    import httpx
+    from afterpython.utils import fetch_pypi_json
+
+    async def fetch_version(
+        client: httpx.AsyncClient, package_name: str
+    ) -> Version | None:
+        """Fetch the latest version of a package from PyPI."""
+        data = await fetch_pypi_json(client, package_name)
+        return Version(data["info"]["version"]) if data else None
+
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        tasks = [fetch_version(client, req.name) for req in requirements]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        return dict(zip([req.name for req in requirements], results, strict=False))
+
+
+def get_dependencies() -> Dependencies:
+    """Get dependencies from pyproject.toml"""
+    from afterpython.tools.pyproject import read_pyproject
+
+    doc: TOMLDocument = read_pyproject()
+    dependencies = {
+        "dependencies": list(doc["project"].get("dependencies", [])),
+        "optional-dependencies": dict(doc["project"].get("optional-dependencies", {})),
+        "dependency-groups": dict(doc.get("dependency-groups", {})),
+        "build-system": dict(doc.get("build-system", {})),
+    }
+    # add "fake_category" to "dependencies" to have the same structure as "optional-dependencies" and "dependency-groups"
+    dependencies["dependencies"] = {"fake_category": dependencies["dependencies"]}
+    # only keep the "requires" key
+    if "requires" in dependencies["build-system"]:
+        dependencies["build-system"] = {
+            "requires": dependencies["build-system"]["requires"]
+        }
+
+    # convert all dependency strings to type "Requirement"
+    for dep_type in dependencies:
+        for category, deps in dependencies[dep_type].items():
+            dependencies[dep_type][category] = [Requirement(dep) for dep in deps]
+
+    # flatten the dependencies to a list of type "Requirement"
+    all_reqs = [
+        req
+        for deps_dict in dependencies.values()
+        for req_list in deps_dict.values()
+        for req in req_list
+    ]
+
+    # Fetch ALL latest versions in ONE async call
+    latest_versions = asyncio.run(get_latest_versions(all_reqs))
+
+    # convert the requirements to type "Dependency"
+    for dep_type in dependencies:
+        for category, requirements in dependencies[dep_type].items():
+            dependencies[dep_type][category] = [
+                Dependency(
+                    **parse_min_max_versions_from_requirement(req),
+                    requirement=req,
+                    latest_version=latest_versions.get(req.name),
+                )
+                for req in requirements
+            ]
+
+    return dependencies
+
+
+def update_dependencies(dependencies: Dependencies):
+    """Update dependency versions in pyproject.toml"""
+    from afterpython.tools.pyproject import read_pyproject, write_pyproject
+
+    doc: TOMLDocument = read_pyproject()
+    for dep_type in dependencies:
+        # category = extras or group name
+        for category, deps in dependencies[dep_type].items():
+            if dep_type == "dependencies":
+                doc_deps = doc["project"][dep_type]
+            elif dep_type == "optional-dependencies":
+                doc_deps = doc["project"][dep_type][category]
+            elif dep_type in ["dependency-groups", "build-system"]:
+                doc_deps = doc[dep_type][category]
+            else:
+                raise ValueError(f"Invalid dependency type: {dep_type}")
+
+            # Update in place
+            for i, (dep, package) in enumerate(zip(deps, doc_deps, strict=False)):
+                package: str  # package = e.g. "click>=8.3.0"
+                req: Requirement = dep.requirement
+                min_ver = str(dep.min_version) if dep.min_version else None
+                max_ver = str(dep.max_version) if dep.max_version else None
+                latest_ver = str(dep.latest_version) if dep.latest_version else None
+                if (
+                    req.name in package
+                    and min_ver
+                    and latest_ver
+                    and min_ver in package
+                ):
+                    doc_deps[i] = package.replace(min_ver, latest_ver)
+                    if max_ver and dep.latest_version not in req.specifier:
+                        doc_deps[i] = doc_deps[i].replace(
+                            max_ver, str(dep.max_version.next_breaking())
+                        )
+
+    write_pyproject(doc)

afterpython/templates/deploy-workflow-template.yml

@@ -0,0 +1,71 @@
+name: Deploy Project Website to GitHub Pages
+
+on:
+  push:
+    branches:
+      - main  # Deploy when pushing to main branch
+    paths:
+      # Trigger deployment only when content or website files change
+      - 'afterpython/doc/**'
+      - 'afterpython/blog/**'
+      - 'afterpython/tutorial/**'
+      - 'afterpython/example/**'
+      - 'afterpython/guide/**'
+      - 'afterpython/static/**'
+      - 'afterpython/_website/**'
+      - 'afterpython/authors.yml'
+      - 'afterpython/faq.yml'
+      - '.github/workflows/deploy.yml'
+  workflow_dispatch:  # Allow manual deployment from Actions tab
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      - name: Install afterpython
+        run: uv pip install --system afterpython
+
+      - name: Build website
+        run: ap build
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './afterpython/_website/build'
+
+  deploy:
+    environment:
+      name: github-pages
+      # This will dynamically generate the deployment URL
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

afterpython/templates/release-workflow-template.yml

@@ -0,0 +1,56 @@
+name: Release to PyPI and GitHub
+
+on:
+  push:
+    tags:
+      - 'v*'  # Trigger on all version tags (v0.1.0, v0.1.0rc1, v0.1.0.dev4, etc.)
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # Required for creating GitHub releases
+      id-token: write  # Required for PyPI trusted publishing
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        run: uv publish
+
+      - name: Determine if pre-release
+        id: check_prerelease
+        run: |
+          # Extract version from tag (remove 'v' prefix)
+          VERSION="${GITHUB_REF_NAME#v}"
+
+          # Check if this is a pre-release or dev version
+          # Matches: dev, rc, alpha, beta, a1, b2 (but not 'stable-version')
+          if [[ "$VERSION" =~ (dev|rc|alpha|beta|a[0-9]+|b[0-9]+) ]]; then
+            echo "prerelease=true" >> $GITHUB_OUTPUT
+          else
+            echo "prerelease=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          generate_release_notes: false
+          prerelease: ${{ steps.check_prerelease.outputs.prerelease }}
+          files: dist/*  # Attach built packages (wheel + sdist)

afterpython/templates/ruff-template.toml

@@ -0,0 +1,32 @@
+# Ruff configuration
+# See More: https://docs.astral.sh/ruff/configuration/
+
+line-length = 88
+target-version = "py311"
+
+[lint]
+# ruff default rules:
+select = [
+    "E4",  # import-related errors (e.g., undefined names in imports)
+    "E7",  # statement errors (e.g., multiple statements on one line)
+    "E9",  # runtime errors (e.g., syntax errors, indentation issues)
+    "F",   # Pyflakes - logical errors (e.g., unused imports, undefined variables)
+]
+# ignored rules:
+ignore = [
+    "E501",  # line too long
+]
+# extended rules:
+extend-select = [
+    # "I",     # isort - import sorting
+    "UP",    # pyupgrade - upgrade syntax for newer Python
+    "B",     # flake8-bugbear - find likely bugs
+    "SIM",   # flake8-simplify - simplify code
+    # "C90",   # mccabe - complexity checking
+    "N",     # pep8-naming - enforce naming conventions
+    "RUF",   # ruff-specific rules
+]
+
+[format]
+quote-style = "double"  # double quotes for strings
+indent-style = "space"  # indent with spaces, rather than tabs.

afterpython/tools/_afterpython.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tomlkit.toml_document import TOMLDocument
+
+import tomlkit
+
+import afterpython as ap
+from afterpython._io.toml import read_toml, write_toml, _to_tomlkit
+
+
+def read_afterpython() -> TOMLDocument:
+    """Read afterpython.toml"""
+    return read_toml(ap.paths.afterpython_path / "afterpython.toml")
+
+
+def update_afterpython(data_update: dict):
+    """Update afterpython.toml
+
+    Args:
+        data_update: dict of data to update
+    """
+    from afterpython.utils import deep_merge
+
+    afterpython_toml_path = ap.paths.afterpython_path / "afterpython.toml"
+
+    # read existing data
+    if not afterpython_toml_path.exists():
+        afterpython_toml_path.touch()
+        existing_data = tomlkit.document()
+    else:
+        with open(afterpython_toml_path, "rb") as f:
+            existing_data = tomlkit.parse(f.read())
+    if existing_data is None:
+        existing_data = tomlkit.document()
+
+    # convert and update existing data
+    # Convert to tomlkit objects to use "array of inline tables" format
+    # e.g. authors = [{name = "..."}] instead of [[docs.authors]] (array of tables)
+    converted_data = _to_tomlkit(data_update)
+
+    existing_data = deep_merge(existing_data, converted_data)
+
+    # write updated data
+    write_toml(afterpython_toml_path, existing_data)
+
+
+def init_afterpython():
+    """Initialize afterpython.toml"""
+    afterpython_toml_path = ap.paths.afterpython_path / "afterpython.toml"
+    if afterpython_toml_path.exists():
+        print(f"afterpython.toml already exists at {afterpython_toml_path}")
+        return
+    afterpython_toml_path.touch()
+    print(f"Created {afterpython_toml_path}")
+    update_afterpython(
+        {
+            "company": {
+                "name": "",
+                "url": "",
+            },
+            "website": {"url": ""},
+        }
+    )

afterpython/tools/_git.py

@@ -0,0 +1,111 @@
+# VIBE-CODED
+import re
+import subprocess
+
+from git import Repo
+
+from afterpython.utils import has_gh
+
+
+def get_git_user_config() -> dict | None:
+    """Get Git user configuration (name and email)."""
+    try:
+        # Get the repo
+        repo = Repo(search_parent_directories=True)
+
+        # Access git config
+        reader = repo.config_reader()
+
+        # Get user name and email
+        name = reader.get_value("user", "name", default=None)
+        email = reader.get_value("user", "email", default=None)
+
+        if not name or not email:
+            return None
+
+        return {"name": name, "email": email}
+    except Exception:
+        return None
+
+
+def get_github_url() -> str | None:
+    """Get GitHub repository URL from git remote origin."""
+    try:
+        # Get the repo
+        repo = Repo(search_parent_directories=True)
+
+        # Get origin remote URL
+        if "origin" not in repo.remotes:
+            return None
+
+        remote_url = repo.remotes.origin.url
+        # Verify it's a GitHub URL
+        if "github.com" not in remote_url:
+            return None
+
+        # Convert SSH format to HTTPS format
+        # git@github.com:user/repo.git -> https://github.com/user/repo
+        if remote_url.startswith("git@github.com:"):
+            remote_url = remote_url.replace("git@github.com:", "https://github.com/")
+
+        # Remove .git suffix if present
+        remote_url = re.sub(r"\.git$", "", remote_url)
+
+        return remote_url
+
+    except (ImportError, Exception):
+        # GitPython not installed or not in a git repo
+        return None
+
+
+def setup_github_auth():
+    """Guide user through GitHub authentication."""
+    if not has_gh():
+        print("""
+╭─────────────────────────────────────────╮
+│  GitHub CLI Required                    │
+╰─────────────────────────────────────────╯
+
+Install it:
+  • macOS:   brew install gh
+  • Linux:   https://github.com/cli/cli/releases
+  • Windows: https://cli.github.com/
+
+        """)
+        return False
+
+    result = subprocess.run(["gh", "auth", "status"], capture_output=True, check=False)
+
+    if result.returncode != 0:
+        print("""
+╭─────────────────────────────────────────╮
+│  GitHub Authentication Required         │
+╰─────────────────────────────────────────╯
+
+Please authenticate with GitHub:
+
+    gh auth login
+
+        """)
+        return False
+
+    print("✓ GitHub authentication verified")
+    return True
+
+
+def get_github_username() -> str | None:
+    """Get authenticated username via gh CLI."""
+    if not has_gh():
+        return None
+
+    result = subprocess.run(
+        ["gh", "api", "user", "--jq", ".login"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+# TODO: use gh's token for pygithub to get repo issues
+# def get_repo_issues(owner: str, repo: str) -> list[dict]:

afterpython/tools/commitizen.py

@@ -0,0 +1,53 @@
+import afterpython as ap
+
+
+commitizen_default = {
+    "tool": {
+        "commitizen": {
+            "name": "cz_conventional_commits",
+            "tag_format": "v$version",
+            "version_scheme": "pep440",
+            "version_provider": "uv",
+            "update_changelog_on_bump": False,
+            "major_version_zero": True,
+        }
+    }
+}
+
+
+commitizen_pre_commit_hook = {
+    "repos": [
+        {
+            "repo": "https://github.com/commitizen-tools/commitizen",
+            "rev": "v4.10.0",
+            "hooks": [
+                {
+                    "id": "commitizen",
+                    "stages": ["commit-msg"],
+                },
+                {
+                    "id": "commitizen-branch",
+                    "stages": ["pre-push"],
+                },
+            ],
+        },
+    ]
+}
+
+
+def init_commitizen():
+    from afterpython.tools.pre_commit import update_pre_commit
+    from afterpython._io.toml import write_toml
+
+    afterpython_path = ap.paths.afterpython_path
+    commitizen_toml_path = afterpython_path / "cz.toml"
+    if commitizen_toml_path.exists():
+        print(f"Commitizen configuration file {commitizen_toml_path} already exists")
+        return
+
+    # Create commitizen configuration with default values
+    write_toml(commitizen_toml_path, commitizen_default)
+    print(f"Created {commitizen_toml_path}")
+
+    # add commitizen hook to .pre-commit-config.yaml
+    update_pre_commit(commitizen_pre_commit_hook)

afterpython/tools/github_actions.py

@@ -0,0 +1,78 @@
+import shutil
+
+import click
+
+import afterpython as ap
+
+
+def init_release_workflow():
+    """Initialize GitHub Actions release workflow.
+
+    Creates .github/workflows/release.yml in the user's project root.
+    This workflow triggers on version tags and:
+    - Builds the package with uv
+    - Publishes to PyPI using trusted publishing
+    - Creates GitHub releases (with pre-release detection)
+    """
+    user_path = ap.paths.user_path
+    workflow_dir = user_path / ".github" / "workflows"
+    workflow_path = workflow_dir / "release.yml"
+
+    if workflow_path.exists():
+        click.echo(f"GitHub Actions release workflow {workflow_path} already exists")
+        return
+
+    # Create .github/workflows directory if it doesn't exist
+    workflow_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy template from package
+    template_path = ap.paths.templates_path / "release-workflow-template.yml"
+    if not template_path.exists():
+        raise FileNotFoundError(
+            f"Template file not found: {template_path}\n"
+            "This might indicate a corrupted installation. Please reinstall afterpython."
+        )
+
+    shutil.copy(template_path, workflow_path)
+    click.echo(f"Created {workflow_path}")
+    click.echo(
+        "\n📋 Next steps to enable releases:\n"
+        "   1. Enable PyPI trusted publishing:\n"
+        "      - Go to https://pypi.org/manage/account/publishing/\n"
+        "      - Add your repository and workflow file: release.yml\n"
+        "   2. Push tags to trigger releases:\n"
+        "      - Use 'ap bump --release' for stable releases (auto-pushes tag)\n"
+        "      - Use 'ap bump --pre' then 'ap release' for pre-releases\n"
+    )
+
+
+def init_deploy_workflow():
+    """Initialize GitHub Actions deployment workflow for GitHub Pages.
+
+    Creates .github/workflows/deploy.yml in the user's project root.
+    This workflow triggers on pushes to main branch and:
+    - Builds the project website with 'ap build'
+    - Deploys to GitHub Pages
+    - Allows manual deployment via workflow_dispatch
+    """
+    user_path = ap.paths.user_path
+    workflow_dir = user_path / ".github" / "workflows"
+    workflow_path = workflow_dir / "deploy.yml"
+
+    if workflow_path.exists():
+        click.echo(f"GitHub Actions deploy workflow {workflow_path} already exists")
+        return
+
+    # Create .github/workflows directory if it doesn't exist
+    workflow_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy template from package
+    template_path = ap.paths.templates_path / "deploy-workflow-template.yml"
+    if not template_path.exists():
+        raise FileNotFoundError(
+            f"Template file not found: {template_path}\n"
+            "This might indicate a corrupted installation. Please reinstall afterpython."
+        )
+
+    shutil.copy(template_path, workflow_path)
+    click.echo(f"Created {workflow_path}")