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

afterpython/cli/commands/build.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from afterpython._typing import NodeEnv
+
+import shutil
+import subprocess
+
+import click
+from click.exceptions import Exit
+
+import afterpython as ap
+from afterpython.builders import (
+    build_content_json,
+    build_jupyter_notebooks,
+    build_markdown,
+    build_metadata,
+    create_placeholder_index_md_files,
+    delete_placeholder_index_md_files,
+)
+from afterpython.const import CONTENT_TYPES
+
+
+def determine_base_path() -> str:
+    """Determine BASE_PATH based on website URL configuration.
+
+    Returns:
+        Empty string if custom domain is configured (no github.io in URL)
+        /repo-name if using default GitHub Pages URL (contains github.io)
+    """
+    from afterpython._io.toml import _from_tomlkit
+    from afterpython.tools._afterpython import read_afterpython
+    from afterpython.tools.pyproject import read_metadata
+
+    # Read website URL from afterpython.toml
+    afterpython = read_afterpython()
+    website_url = str(_from_tomlkit(afterpython.get("website", {})).get("url", ""))
+
+    # If custom domain (no github.io), no BASE_PATH needed
+    if "github.io" not in website_url:
+        return ""
+
+    # For GitHub Pages default URL, extract repo name from repository URL
+    pyproject = read_metadata()
+    github_url = str(pyproject.urls.get("repository", ""))
+
+    if not github_url:
+        click.echo(
+            "Warning: No repository URL found in pyproject.toml, using empty BASE_PATH"
+        )
+        return ""
+
+    # Extract repo name from URL like "https://github.com/AfterPythonOrg/afterpython"
+    # -> "afterpython"
+    repo_name = github_url.rstrip("/").split("/")[-1]
+    return f"/{repo_name}"
+
+
+def prebuild():
+    def _check_initialized():
+        # Check if 'ap init' has been run
+        afterpython_toml = ap.paths.afterpython_path / "afterpython.toml"
+        if not afterpython_toml.exists():
+            raise click.ClickException(
+                "AfterPython is not initialized!\n"
+                "Run 'ap init' first to set up your project."
+            )
+
+    def _clean_up_builds():
+        click.echo("Cleaning up builds...")
+        build_path = ap.paths.build_path
+        website_build_path = ap.paths.website_path / "build"
+        # clean up content builds in _website/static/{content_type}
+        website_static_path = ap.paths.website_path / "static"
+        content_build_paths = [
+            website_static_path / content_type for content_type in CONTENT_TYPES
+        ]
+        for path in [build_path, website_build_path, *content_build_paths]:
+            if path.exists():
+                shutil.rmtree(path)
+        build_path.mkdir(parents=True, exist_ok=True)
+
+    _check_initialized()
+    _clean_up_builds()
+
+    delete_placeholder_index_md_files()
+    create_placeholder_index_md_files()
+    build_metadata()
+    build_markdown()
+    build_jupyter_notebooks()
+
+
+def postbuild(dev_build: bool = False):
+    def _move_files(
+        source: Path,
+        destination: Path,
+        is_copy: bool = True,
+        ignore_copy: Callable[[str, list[str]], set[str]] | None = None,
+    ):
+        """
+        Move or copy files from source to destination.
+
+        Args:
+            source: Source path
+            destination: Destination path
+            is_copy: If True, copy files (merge with existing). If False, move files (replace destination)
+            ignore_copy: Optional ignore function for copytree, takes (directory, contents) and returns set of names to ignore
+        """
+        if not source.exists():
+            return
+        if is_copy:
+            shutil.copytree(source, destination, dirs_exist_ok=True, ignore=ignore_copy)
+            print(f"Copied: {source} to {destination}")
+        else:
+            # Remove destination if it exists (move will fail otherwise)
+            if destination.exists():
+                shutil.rmtree(destination)
+            shutil.move(str(source), str(destination))
+            print(f"Moved: {source} to {destination}")
+
+    build_content_json()
+    delete_placeholder_index_md_files()
+
+    website_static = ap.paths.website_path / "static"
+    website_static.mkdir(parents=True, exist_ok=True)
+
+    for content_type in CONTENT_TYPES:
+        myst_build = ap.paths.afterpython_path / content_type / "_build"
+        afterpython_content_build = ap.paths.build_path / content_type
+        # Move myst builds from afterpython/{content_type}/_build to afterpython/_build/{content_type}
+        _move_files(myst_build, afterpython_content_build, is_copy=True)
+        # for production build, copy afterpython/_build/{content_type}/html to afterpython/_website/static/{content_type}
+        if not dev_build:
+            _move_files(
+                afterpython_content_build / "html",
+                website_static / content_type,
+                is_copy=True,
+            )
+        # for dev build, copy the files (mainly images, e.g. thumbnails) in site/public/ to afterpython/_website/static/{content_type}/build
+        else:
+            _move_files(
+                afterpython_content_build / "site" / "public",
+                # add build/ to mimic the structure of the production build
+                website_static / content_type / "build",
+                is_copy=True,
+            )
+
+    # Copy all files (e.g. metadata.json, blog.json etc.) from afterpython/_build to afterpython/_website/static/
+    _move_files(
+        ap.paths.build_path,
+        website_static,
+        is_copy=True,
+        # ignore all content builds e.g. doc/, blog/, only their html/ files will be copied
+        ignore_copy=lambda dir, contents: [
+            name for name in contents if name in CONTENT_TYPES
+        ],
+    )
+
+    # Copy all static files from afterpython/static/ to afterpython/_website/static/
+    _move_files(ap.paths.static_path, website_static, is_copy=True)
+
+
+@click.command(
+    add_help_option=False,  # disable click's --help option so that ap build --help can work
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
+@click.pass_context
+@click.option(
+    "--execute", is_flag=True, help="Execute Jupyter notebooks for all content types"
+)
+def build(ctx: click.Context, execute: bool):
+    """Build the project website and all contents for production.
+
+    This command builds MyST content (doc/blog/tutorial/example/guide) and the SvelteKit website.
+
+    Any extra arguments are passed to the 'myst build --html' command for each content type.
+    See "myst build --help" for more details.
+
+    Use --execute to execute Jupyter notebooks for all content types.
+    """
+    from afterpython.utils import (
+        find_node_env,
+        handle_passthrough_help,
+        has_content_for_myst,
+    )
+
+    # Show both our options and myst's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["myst", "build"],
+        show_underlying=True,
+    )
+
+    paths = ctx.obj["paths"]
+    prebuild()
+
+    # Determine BASE_PATH based on website URL configuration
+    base_path = determine_base_path()
+    if base_path:
+        click.echo(f"Using BASE_PATH: {base_path}")
+    else:
+        click.echo("Using BASE_PATH: (empty - custom domain)")
+    node_env: NodeEnv = find_node_env()
+
+    # myst's production build
+    for content_type in CONTENT_TYPES:
+        content_path = ap.paths.afterpython_path / content_type
+        myst_yml_path = content_path / "myst.yml"
+
+        if not content_path.exists():
+            click.echo(f"{content_path} does not exist, skip building {content_type}/")
+            continue
+
+        if not myst_yml_path.exists():
+            click.echo(
+                f"No myst.yml found in {content_path}, skip building {content_type}/"
+            )
+            continue
+
+        if not has_content_for_myst(content_path):
+            click.echo(f"Skipping {content_type}/ (no content files found)")
+            continue
+
+        click.echo(f"Building {content_type}/...")
+        # NOTE: needs to set BASE_URL (used by MyST) so that the project website can link to the content pages correctly at e.g. localhost:5173/doc
+        base_url = f"{base_path}/{content_type}"
+        build_env = {**node_env, "BASE_URL": base_url, "BASE_PATH": base_path}
+        result = subprocess.run(
+            [
+                "myst",
+                "build",
+                "--html",
+                *(["--execute"] if execute else []),
+                *ctx.args,
+            ],
+            cwd=content_path,
+            env=build_env,
+            check=False,
+        )
+
+        if result.returncode != 0:
+            raise Exit(result.returncode)
+
+    postbuild(dev_build=False)
+
+    click.echo("Building project website...")
+    website_env = {**node_env, "BASE_PATH": base_path}
+    result = subprocess.run(
+        ["pnpm", "build"], cwd=paths.website_path, env=website_env, check=False
+    )
+    if result.returncode != 0:
+        raise Exit(result.returncode)

afterpython/cli/commands/bump.py

@@ -0,0 +1,118 @@
+import subprocess
+
+import click
+from click.exceptions import Exit
+
+from afterpython.utils import has_pixi
+
+
+@click.command(
+    add_help_option=False,  # disable click's --help option so that cz --help can work
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
+@click.pass_context
+@click.option(
+    "--pre",
+    is_flag=True,
+    help="bump to pre-release version (e.g., dev3 -> rc0, a1 -> a2)",
+)
+@click.option(
+    "--release", is_flag=True, help="bump to stable release (uses cz bump default)"
+)
+def bump(ctx, release: bool, pre: bool):
+    """Bump project version with granular control.
+
+    By default, stays within current release phase:
+    - Dev releases (e.g., 0.1.0.dev3) -> increment dev number (0.1.0.dev4)
+    - Pre-releases (e.g., 0.1.0a1) -> increment pre-release (0.1.0a2)
+
+    Use --pre to transition from dev to pre-release, or pre-release to next pre-release.
+    Use --release to bump to next stable version (cz bump default behavior).
+    """
+    from afterpython.tools.pyproject import read_metadata
+    from afterpython.utils import handle_passthrough_help
+
+    # Show both our options and commitizen's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["cz", "bump"],
+        show_underlying=True,
+    )
+
+    if release and pre:
+        raise click.ClickException("Only one of --release or --pre can be specified")
+
+    # bump using cz bump's default behavior
+    if release:
+        subprocess.run(["ap", "cz", "bump", *ctx.args])
+
+        # Skip tag push if this is a dry run
+        if "--dry-run" in ctx.args:
+            return
+
+        # Get the new version after bump
+        metadata = read_metadata()
+        new_version = metadata.version
+        if new_version is None:
+            raise click.ClickException("Unable to read version after bump")
+
+        tag = f"v{new_version}"
+
+        # Auto-push the specific tag to trigger release workflow
+        click.echo(f"\n🚀 Pushing tag {tag} to trigger release workflow...")
+        subprocess.run(["git", "push", "origin", tag])
+    else:
+        metadata = read_metadata()
+        version = metadata.version
+
+        if version is None:
+            raise click.ClickException("Unable to read version from pyproject.toml")
+
+        args = ctx.args  # default: pass through all extra args
+
+        # by default, bump dev-release version
+        if version.is_devrelease and not pre:
+            devrelease_number = int(version.dev)
+            if "--devrelease" not in ctx.args:
+                args = ["--devrelease", str(devrelease_number + 1), *ctx.args]
+        # exclude e.g. 0.1.0.dev1 which is both dev-release and pre-release (with version.pre = None)
+        elif version.is_prerelease:
+            prerelease_type = version.pre[0] if version.pre is not None else "rc"
+            if prerelease_type == "a":
+                prerelease_type = "alpha"
+            elif prerelease_type == "b":
+                prerelease_type = "beta"
+            if "--prerelease" not in ctx.args:
+                args = ["--prerelease", prerelease_type, *ctx.args]
+
+        subprocess.run(["ap", "cz", "bump", *args])
+
+    # Update pixi.lock after version bump (editable install requires lock refresh)
+    if has_pixi():
+        result = subprocess.run(["pixi", "install"], check=False)
+        if result.returncode != 0:
+            raise Exit(result.returncode)
+
+        # Check if pixi.lock was modified
+        status = subprocess.run(
+            ["git", "diff", "--name-only", "pixi.lock"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if status.stdout.strip():
+            # Stage and commit pixi.lock
+            subprocess.run(["git", "add", "pixi.lock"], check=True)
+            subprocess.run(
+                [
+                    "git",
+                    "commit",
+                    "-m",
+                    "build: update pixi.lock after version bump",
+                ],
+                check=True,
+            )
+            click.echo("✓ Committed pixi.lock update")

afterpython/cli/commands/check.py

@@ -0,0 +1,36 @@
+import subprocess
+
+import click
+from click.exceptions import Exit
+
+
+@click.command(
+    add_help_option=False,  # disable click's --help option so that ruff check --help can work
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
+@click.pass_context
+def check(ctx):
+    """Run ruff linter (uses afterpython/ruff.toml if available)"""
+    from afterpython.utils import handle_passthrough_help
+
+    # Show both our options and ruff's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["ruff", "check"],
+        show_underlying=True,
+    )
+
+    paths = ctx.obj["paths"]
+    ruff_toml = paths.afterpython_path / "ruff.toml"
+    if ruff_toml.exists():
+        click.echo(f"Using ruff configuration from {ruff_toml}")
+        result = subprocess.run(
+            ["ruff", "check", "--config", str(ruff_toml), *ctx.args], check=False
+        )
+    else:
+        result = subprocess.run(["ruff", "check", *ctx.args], check=False)
+    if result.returncode != 0:
+        raise Exit(result.returncode)

afterpython/cli/commands/clean.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from afterpython._typing import NodeEnv
+
+import shutil
+import subprocess
+
+import click
+from click.exceptions import Exit
+
+from afterpython.const import CONTENT_TYPES
+from afterpython.utils import find_node_env, has_content_for_myst
+
+
+@click.command(
+    add_help_option=False,  # disable click's --help option so that ap clean --help can work
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
+@click.pass_context
+@click.option(
+    "--all",
+    is_flag=True,
+    help="Also clean AfterPython build directories (_build/ and _website/build/)",
+)
+def clean(ctx, all: bool):
+    """Clean build artifacts from content types and website"""
+    from afterpython.utils import handle_passthrough_help
+
+    # Show both our options and myst's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["myst", "clean"],
+        show_underlying=True,
+    )
+
+    paths = ctx.obj["paths"]
+    node_env: NodeEnv = find_node_env()
+
+    # Clean MyST builds for each content type
+    for content_type in CONTENT_TYPES:
+        content_path = paths.afterpython_path / content_type
+
+        # Skip if no content exists
+        if not has_content_for_myst(content_path):
+            click.echo(f"Skipping {content_type}/ (no content found)")
+            continue
+
+        click.echo(f"Cleaning {content_type}/...")
+        # Pass through any extra args to myst clean (e.g., --cache, --templates)
+        result = subprocess.run(
+            ["myst", "clean", *ctx.args, *(["--all"] if all else [])],
+            cwd=content_path,
+            env=node_env,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise Exit(result.returncode)
+
+    # Clean afterpython's build directories if --all flag is used
+    if all:
+        click.echo("Cleaning afterpython build directories...")
+
+        # Clean _build/
+        build_path = paths.build_path
+        if build_path.exists():
+            shutil.rmtree(build_path)
+            click.echo(f"  Removed: {build_path}")
+
+        # Clean _website/build/
+        website_build = paths.website_path / "build"
+        if website_build.exists():
+            shutil.rmtree(website_build)
+            click.echo(f"  Removed: {website_build}")
+
+        click.echo("Done cleaning all build directories!")
+    else:
+        click.echo(
+            "Done! Use 'ap clean --all' to also remove afterpython build directories."
+        )

afterpython/cli/commands/commit.py

@@ -0,0 +1,52 @@
+import os
+import subprocess
+
+import click
+
+
+@click.command(
+    add_help_option=False,  # disable click's --help option so that cz --help can work
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
+@click.pass_context
+@click.option(
+    "--no-cz",
+    "--no-commitizen",
+    is_flag=True,
+    help="Skip 'commitizen' and 'commitizen-branch' pre-commit hooks",
+)
+@click.option(
+    "--no-pc",
+    "--no-pre-commit",
+    is_flag=True,
+    help="Skip running pre-commit checks before commit",
+)
+def commit(ctx, no_cz: bool, no_pc: bool):
+    """Create a conventional commit with interactive prompts"""
+    from afterpython.utils import handle_passthrough_help
+
+    # Show both our options and commitizen's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["cz", "commit"],
+        show_underlying=True,
+    )
+
+    # Run pre-commit checks first (unless --no-pc is set)
+    if not no_pc:
+        result = subprocess.run(["ap", "pc", "run"])
+        if result.returncode != 0:
+            click.echo(
+                "❌ Pre-commit checks failed. Please fix the issues and try again."
+            )
+            ctx.exit(1)
+
+    if not no_cz:
+        subprocess.run(["ap", "cz", "commit", *ctx.args])
+    else:
+        env = os.environ.copy()
+        env["SKIP"] = "commitizen,commitizen-branch"
+        subprocess.run(["git", "commit", *ctx.args], env=env)

afterpython/cli/commands/commitizen.py

@@ -0,0 +1,32 @@
+import subprocess
+
+import click
+from click.exceptions import Exit
+
+
+@click.command(
+    add_help_option=False,  # disable click's --help option so that cz --help can work
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
+@click.pass_context
+def commitizen(ctx):
+    """Run commitizen CLI (uses afterpython/cz.toml)"""
+    from afterpython.utils import handle_passthrough_help
+
+    # Show both our options and commitizen's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["cz"],
+        show_underlying=True,
+    )
+
+    paths = ctx.obj["paths"]
+    cz_toml_path = paths.afterpython_path / "cz.toml"
+    result = subprocess.run(
+        ["cz", "--config", str(cz_toml_path), *ctx.args], check=False
+    )
+    if result.returncode != 0:
+        raise Exit(result.returncode)