afterpython 0.1.0__py3-none-any.whl → 0.1.0.dev6__py3-none-any.whl

afterpython/templates/ruff-template.toml

@@ -18,7 +18,7 @@ ignore = [
 ]
 # extended rules:
 extend-select = [
-    "I",     # isort - import sorting
+    # "I",     # isort - import sorting
     "UP",    # pyupgrade - upgrade syntax for newer Python
     "B",     # flake8-bugbear - find likely bugs
     "SIM",   # flake8-simplify - simplify code

afterpython/tools/_afterpython.py

@@ -1,71 +1,13 @@
 from __future__ import annotations
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
     from tomlkit.toml_document import TOMLDocument
 
-    from afterpython._typing import tContentType
-
 import tomlkit
 
 import afterpython as ap
-from afterpython._io.toml import _to_tomlkit, read_toml, write_toml
-
-
-def get_default_thumbnail(
-    content_type: tContentType, file_path: Path | None = None
-) -> str:
-    """Get the default thumbnail value for a content type.
-
-    Reads default thumbnail configuration from afterpython.toml:
-    - Content type specific thumbnail: [website.{content_type}.thumbnail]
-    - Website-wide default thumbnail: [website.thumbnail]
-    - Falls back to empty string if no default is configured
-
-    Args:
-        content_type: The content type (blog, tutorial, etc.)
-        file_path: Optional path to the file needing the thumbnail (for calculating relative path)
-
-    Returns:
-        The thumbnail value to use (e.g., "./static/image.png", "../static/image.png", or "")
-    """
-    from afterpython._io.toml import _from_tomlkit
-    from afterpython.utils import get_relative_static_prefix, normalize_static_path
-
-    afterpython = read_afterpython()
-    try:
-        # website_default_thumbnail = normalize_static_path(
-        #     str(_from_tomlkit(afterpython.get("website", {})).get("thumbnail", ""))
-        # )
-        content_type_default_thumbnail = normalize_static_path(
-            str(
-                _from_tomlkit(afterpython.get("website", {}))
-                .get(content_type, {})
-                .get("thumbnail", "")
-            )
-        )
-    except ValueError as e:
-        print(f"Error in reading afterpython.toml for {content_type=}: {e}")
-        return "null"
-
-    # Determine the static prefix based on file location
-    if file_path is not None:
-        content_type_path = ap.paths.afterpython_path / content_type.lower()
-        static_prefix = get_relative_static_prefix(file_path, content_type_path)
-    else:
-        static_prefix = "./"  # Default fallback
-
-    if content_type_default_thumbnail:
-        return f"{static_prefix}static{content_type_default_thumbnail}"
-    # use "thumbnail" set in afterpython.toml [website]
-    # elif website_default_thumbnail:
-    # Website-wide static is one level up from content_type folder
-    # return f"{static_prefix}../static{website_default_thumbnail}"
-    else:
-        return ""
+from afterpython._io.toml import read_toml, write_toml, _to_tomlkit
 
 
 def read_afterpython() -> TOMLDocument:
@@ -112,17 +54,12 @@ def init_afterpython():
         return
     afterpython_toml_path.touch()
     print(f"Created {afterpython_toml_path}")
-    default_data = {
-        "company": {
-            "name": "",
-            "url": "",
-        },
-        "website": {
-            "url": "",
-            "favicon": "favicon.svg",
-            "logo": "logo.svg",
-            "logo_dark": "logo.svg",
-            "thumbnail": "thumbnail.png",
-        },
-    }
-    update_afterpython(default_data)
+    update_afterpython(
+        {
+            "company": {
+                "name": "",
+                "url": "",
+            },
+            "website": {"url": ""},
+        }
+    )

afterpython/tools/_git.py

@@ -58,7 +58,7 @@ def get_github_url() -> str | None:
         return None
 
 
-def is_gh_authenticated():
+def setup_github_auth():
     """Guide user through GitHub authentication."""
     if not has_gh():
         print("""
@@ -89,6 +89,7 @@ Please authenticate with GitHub:
         """)
         return False
 
+    print("✓ GitHub authentication verified")
     return True
 
 
@@ -106,32 +107,5 @@ def get_github_username() -> str | None:
     return result.stdout.strip()
 
 
-def get_current_user_id() -> int | None:
-    """
-    Get the GitHub user ID of the currently authenticated user.
-
-    Returns:
-        User ID or None if error
-    """
-    if not is_gh_authenticated():
-        return None
-
-    result = subprocess.run(
-        ["gh", "api", "user", "--jq", ".id"],
-        capture_output=True,
-        text=True,
-    )
-
-    if result.returncode != 0:
-        print(f"Error fetching user ID: {result.stderr}")
-        return None
-
-    try:
-        return int(result.stdout.strip())
-    except ValueError:
-        print("Error: Failed to parse user ID")
-        return None
-
-
 # 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

@@ -1,13 +1,53 @@
-import shutil
-
 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():
-    commitizen_toml_path = ap.paths.afterpython_path / "cz.toml"
+    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
-    cz_template_path = ap.paths.templates_path / "cz-template.toml"
-    shutil.copy(cz_template_path, commitizen_toml_path)
+
+    # 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

@@ -1,48 +1,78 @@
 import shutil
-from pathlib import Path
 
 import click
 
 import afterpython as ap
 
 
-def _copy_github_template(template_name: str, target_path: Path):
-    """Helper to copy GitHub-related templates"""
-    if target_path.exists():
-        click.echo(f"{target_path} already exists")
+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 parent directory if it doesn't exist
-    target_path.parent.mkdir(parents=True, exist_ok=True)
+    # 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 / template_name
+    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, target_path)
-    print(f"Created {target_path}")
+    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 create_workflow(workflow_name: str):
-    """Create a GitHub Actions workflow from template"""
-    if ".yml" in workflow_name:
-        workflow_name = workflow_name.replace(".yml", "")
+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_path = user_path / ".github" / "workflows" / f"{workflow_name}.yml"
-    template_name = f"{workflow_name}-workflow-template.yml"
+    workflow_dir = user_path / ".github" / "workflows"
+    workflow_path = workflow_dir / "deploy.yml"
 
-    _copy_github_template(template_name, workflow_path)
+    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)
 
-def create_dependabot():
-    """Create Dependabot configuration for GitHub Actions updates"""
-    user_path = ap.paths.user_path
-    dependabot_path = user_path / ".github" / "dependabot.yml"
-    template_name = "dependabot-template.yml"
+    # 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."
+        )
 
-    _copy_github_template(template_name, dependabot_path)
+    shutil.copy(template_path, workflow_path)
+    click.echo(f"Created {workflow_path}")

afterpython/tools/myst.py

@@ -1,17 +1,15 @@
 from __future__ import annotations
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from pathlib import Path
-
-    from afterpython._typing import NodeEnv, tContentType
+    from afterpython._typing import tContentType, NodeEnv
 
 import subprocess
 
 import afterpython as ap
-from afterpython._io.yaml import read_yaml, write_yaml
 from afterpython.utils import deep_merge
+from afterpython._io.yaml import write_yaml, read_yaml
 
 
 def update_authors_yml(data_update: dict):
@@ -103,48 +101,6 @@ def update_myst_yml(data_update: dict, path: Path, add_comments: bool = False):
     write_yaml(file_path, existing_data)
 
 
-def _write_index_file(content_type: tContentType):
-    """Create a placeholder index.md file for MyST to prevent first file from becoming index.
-
-    MyST treats the first file in TOC as index. This placeholder ensures all actual
-    content files get proper slugs. The generated index.html is deleted post-build
-    since SvelteKit owns the landing page route.
-
-    Note: This only creates the file. TOC modification is handled by the build process.
-
-    Raises:
-        FileExistsError: If index.md already exists (users shouldn't create this file).
-    """
-    if content_type == "doc":
-        return  # Doc doesn't need a placeholder index.md
-
-    content_path = ap.paths.afterpython_path / content_type
-    index_file = content_path / "index.md"
-
-    # Check if user created an index.md file
-    if index_file.exists():
-        raise FileExistsError(
-            f"\n"
-            f"Found existing 'index.md' in afterpython/{content_type}/\n"
-            f"\n"
-            f"The 'index.md' file is reserved for internal use by AfterPython.\n"
-            f"MyST treats the first file in TOC as index, which would conflict with\n"
-            f"SvelteKit (project-website-template)'s landing page route (/{content_type}).\n"
-            f"\n"
-            f"Please rename your file to something else (e.g., '{content_type}_intro.md')\n"
-            f"and update the reference in afterpython/{content_type}/myst.yml"
-        )
-
-    index_content = f"""---
-title: ← {content_type.capitalize()}
----
-
-This is a placeholder index page. The actual {content_type} landing page is rendered by SvelteKit.
-"""
-    index_file.write_text(index_content)
-    return index_file
-
-
 def _write_welcome_file(content_type: tContentType):
     welcome_file = ap.paths.afterpython_path / content_type / "index.md"
     if welcome_file.exists():
@@ -198,6 +154,9 @@ def init_myst():
             },
             "site": {
                 "options": {
+                    "favicon": "../static/favicon.ico",
+                    "logo": "../static/logo.svg",
+                    "logo_dark": "../static/logo.svg",
                     "analytics_google": "{{ GOOGLE_ANALYTICS_ID }}",
                     # "twitter": "",
                 },

afterpython/tools/pre_commit.py

@@ -1,8 +1,36 @@
-import shutil
 import subprocess
 
 import afterpython as ap
-from afterpython._io.yaml import read_yaml, write_yaml
+
+from afterpython._io.yaml import write_yaml, read_yaml
+
+
+pre_commit_default = {
+    # default is only ["pre-commit"], without changing the default,
+    # we need to explicitly pass in --hook-type whenever we run "pre-commit install --hook-type ..."
+    "default_install_hook_types": ["pre-commit", "commit-msg", "pre-push"],
+    "exclude": "^afterpython/_website/",  # do not check the project website template
+    "repos": [
+        {
+            "repo": "https://github.com/pre-commit/pre-commit-hooks",
+            "rev": "v6.0.0",
+            "hooks": [
+                {"id": "trailing-whitespace", "stages": ["pre-commit"]},
+                {"id": "end-of-file-fixer", "stages": ["pre-commit"]},
+                {"id": "check-yaml", "stages": ["pre-commit"]},
+                {"id": "check-toml", "stages": ["pre-commit"]},
+                {"id": "check-added-large-files", "stages": ["pre-commit"]},
+            ],
+        },
+        # {
+        #     "repo": "https://github.com/astral-sh/uv-pre-commit",
+        #     "rev": "0.9.8",
+        #     "hooks": [
+        #         {"id": "uv-lock"},  # Update the uv lockfile
+        #     ]
+        # },
+    ],
+}
 
 
 def install_pre_commit():
@@ -29,9 +57,6 @@ def init_pre_commit():
     if pre_commit_path.exists():
         print(f".pre-commit-config.yaml already exists at {pre_commit_path}")
         return
-    pre_commit_template_path = (
-        ap.paths.templates_path / "pre-commit-config-template.yaml"
-    )
-    shutil.copy(pre_commit_template_path, pre_commit_path)
+    write_yaml(pre_commit_path, pre_commit_default)
     print(f"Created {pre_commit_path}")
     install_pre_commit()

afterpython/tools/pyproject.py

@@ -1,17 +1,15 @@
 from __future__ import annotations
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from tomlkit.toml_document import TOMLDocument
 
 import asyncio
-from pathlib import Path
 
 from pyproject_metadata import StandardMetadata
 
 import afterpython as ap
-from afterpython._io.toml import _to_tomlkit, read_toml, write_toml
+from afterpython._io.toml import read_toml, write_toml, _to_tomlkit
 
 
 def read_pyproject() -> TOMLDocument:
@@ -28,50 +26,14 @@ def read_metadata() -> StandardMetadata:
     return StandardMetadata.from_pyproject(read_pyproject())
 
 
-def find_package_directory() -> Path:
-    """Find the user's package directory.
-
-    Supports both common Python project layouts:
-    - src layout: user_project/src/package_name/__init__.py
-    - flat layout: user_project/package_name/__init__.py
-
-    Returns:
-        Path to the package directory containing __init__.py
-
-    Raises:
-        FileNotFoundError: If package directory cannot be found in either layout
-    """
-    metadata = read_metadata()
-    package_name = metadata.name
-    project_root = ap.paths.user_path
-
-    # Try src layout first (recommended layout)
-    src_layout_dir = project_root / "src" / package_name
-    if (src_layout_dir / "__init__.py").exists():
-        return src_layout_dir
-
-    # Try flat layout
-    flat_layout_dir = project_root / package_name
-    if (flat_layout_dir / "__init__.py").exists():
-        return flat_layout_dir
-
-    # Package not found in either location
-    raise FileNotFoundError(
-        f"Could not find package '{package_name}' in either src layout "
-        f"({src_layout_dir}) or flat layout ({flat_layout_dir}). "
-        f"Expected to find __init__.py in one of these locations."
-    )
-
-
 def init_pyproject():
     """Initialize pyproject.toml with sensible defaults
     - add [build-system] section with uv build backend (same as `uv init --package`)
     - add [project.urls] section with homepage, repository, and documentation URLs
     """
     import httpx
-
-    from afterpython.tools._git import get_git_user_config, get_github_url
     from afterpython.utils import fetch_pypi_json
+    from afterpython.tools._git import get_git_user_config, get_github_url
 
     build_backend = "uv_build"
 

afterpython/utils.py

@@ -1,12 +1,9 @@
 from __future__ import annotations
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from pathlib import Path
-
     from httpx import AsyncClient
-
     from afterpython._typing import NodeEnv
 
 import os
@@ -23,7 +20,6 @@ def find_node_env() -> NodeEnv:
     If no, install the Node.js version specified in NODEENV_VERSION
     """
     from mystmd_py.nodeenv import find_any_node
-
     from afterpython.const import NODEENV_VERSION
 
     # from mystmd_py.main import ensure_valid_version
@@ -39,11 +35,6 @@ def has_uv() -> bool:
     return shutil.which("uv") is not None
 
 
-def has_pixi() -> bool:
-    """Check if pixi is installed"""
-    return shutil.which("pixi") is not None
-
-
 def has_gh() -> bool:
     """Check if gh is installed"""
     return shutil.which("gh") is not None
@@ -224,76 +215,3 @@ def handle_passthrough_help(
             subprocess.run([*underlying_command, "--help"])
 
         ctx.exit(0)
-
-
-def normalize_static_path(path: str) -> str:
-    """
-    Normalize paths for static assets.
-
-    Only allows two formats:
-    1. Pure filename/path without ./ or ../ (e.g., "logo.svg", "somewhere/logo.svg")
-    2. Absolute path starting with / (e.g., "/somewhere/logo.svg")
-
-    Args:
-        path: User-provided path from afterpython.toml
-
-    Returns:
-        Normalized path
-
-    Raises:
-        ValueError: If path contains ./ or ../ or other invalid patterns
-
-    Examples:
-        >>> normalize_static_path("logo.svg")
-        'logo.svg'
-        >>> normalize_static_path("somewhere/logo.svg")
-        '/somewhere/logo.svg'
-        >>> normalize_static_path("/somewhere/logo.svg")
-        '/somewhere/logo.svg'
-        >>> normalize_static_path("./logo.svg")  # Raises ValueError
-        >>> normalize_static_path("../logo.svg")  # Raises ValueError
-        >>> normalize_static_path("static/logo.svg")  # Raises ValueError
-    """
-    if not path:
-        return ""
-
-    # Reject paths with ./ or ../
-    if "./" in path or "../" in path or path.startswith(".") or path.startswith(".."):
-        raise ValueError(
-            f"Invalid path '{path}': paths cannot contain './' or '../'. "
-            f"Use either a pure filename (e.g., 'logo.svg') or absolute path (e.g., '/somewhere/logo.svg')"
-        )
-
-    # Reject paths with 'static' in them
-    if "static" in path.lower():
-        raise ValueError(
-            f"Invalid path '{path}': do not include 'static' in the path. "
-            f"Files are assumed to be in the static/ directory."
-        )
-
-    # If it starts with /, it's absolute - keep as is
-    if not path.startswith("/"):
-        return "/" + path
-    else:
-        return path
-
-
-def get_relative_static_prefix(file_path: Path, content_type_path: Path) -> str:
-    """Calculate the relative path prefix from a file to its content type's static/ folder.
-
-    Args:
-        file_path: Path to the content file (e.g., blog/layer/blog5.ipynb)
-        content_type_path: Path to the content type folder (e.g., blog/)
-
-    Returns:
-        Relative prefix to reach static/ (e.g., "./" or "../" or "../../")
-    """
-    # Get the depth: how many directories deep the file is from content_type_path
-    relative = file_path.parent.relative_to(content_type_path)
-    depth = len(relative.parts)
-
-    # Build the correct prefix
-    if depth == 0:
-        return "./"  # File is directly in content_type_path
-    else:
-        return "../" * depth