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

afterpython/cli/commands/start.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from afterpython._typing import NodeEnv
+
+import subprocess
+
+import click
+from click.exceptions import Exit
+
+
+command_kwargs = {
+    "add_help_option": False,  # disable click's --help option so that myst start --help can work
+    "context_settings": dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+}
+
+
+@click.command(**command_kwargs)
+@click.pass_context
+@click.option(
+    "--doc", is_flag=True, help="Start the development server for doc/ directory"
+)
+@click.option(
+    "--blog", is_flag=True, help="Start the development server for blog/ directory"
+)
+@click.option(
+    "--tutorial",
+    is_flag=True,
+    help="Start the development server for tutorial/ directory",
+)
+@click.option(
+    "--example",
+    is_flag=True,
+    help="Start the development server for example/ directory",
+)
+@click.option(
+    "--guide", is_flag=True, help="Start the development server for guide/ directory"
+)
+def start(ctx, doc: bool, blog: bool, tutorial: bool, example: bool, guide: bool):
+    """Simple wrapper for `myst start` for convenience"""
+    from afterpython.utils import find_node_env, has_content_for_myst
+    from afterpython.const import CONTENT_TYPES
+    from afterpython.utils import handle_passthrough_help
+
+    # Show both our options and myst's help and exit
+    handle_passthrough_help(
+        ctx,
+        ["myst", "start"],
+        show_underlying=True,
+    )
+
+    node_env: NodeEnv = find_node_env()
+    paths = ctx.obj["paths"]
+
+    if doc:
+        content_type = "doc"
+    elif blog:
+        content_type = "blog"
+    elif tutorial:
+        content_type = "tutorial"
+    elif example:
+        content_type = "example"
+    elif guide:
+        content_type = "guide"
+    else:
+        raise click.ClickException("No content type specified")
+
+    assert content_type in CONTENT_TYPES, f"Invalid content type: {content_type}"
+
+    # assert only one of the options is True
+    if sum([doc, blog, tutorial, example, guide]) != 1:
+        raise click.ClickException("Only one content type can be specified")
+
+    content_path = paths.afterpython_path / content_type
+
+    # Check if directory has any content files
+    if not has_content_for_myst(content_path):
+        click.echo(f"Skipping {content_type}/ (no content files found)")
+        return
+
+    result = subprocess.run(
+        ["myst", "start", *ctx.args], cwd=content_path, env=node_env, check=False
+    )
+    if result.returncode != 0:
+        raise Exit(result.returncode)
+
+
+def _run(ctx):
+    # Get the name of the function that called _run
+    import inspect
+
+    caller_frame = inspect.currentframe().f_back
+    command_name = (
+        caller_frame.f_code.co_name
+    )  # e.g. doc, blog, tutorial, example, guide
+
+    # Create a new context for start that includes extra args for `myst start`
+    with start.make_context(
+        "start", [f"--{command_name}", *ctx.args], parent=ctx.parent
+    ) as start_ctx:
+        return start.invoke(start_ctx)
+
+
+@click.command(**command_kwargs)
+@click.pass_context
+def doc(ctx):
+    """Start the development server for doc/ directory (equivalent to: start --doc)"""
+    _run(ctx)
+
+
+@click.command(**command_kwargs)
+@click.pass_context
+def blog(ctx):
+    """Start the development server for blog/ directory (equivalent to: start --blog)"""
+    _run(ctx)
+
+
+@click.command(**command_kwargs)
+@click.pass_context
+def tutorial(ctx):
+    """Start the development server for tutorial/ directory (equivalent to: start --tutorial)"""
+    _run(ctx)
+
+
+@click.command(**command_kwargs)
+@click.pass_context
+def example(ctx):
+    """Start the development server for example/ directory (equivalent to: start --example)"""
+    _run(ctx)
+
+
+@click.command(**command_kwargs)
+@click.pass_context
+def guide(ctx):
+    """Start the development server for guide/ directory (equivalent to: start --guide)"""
+    _run(ctx)

afterpython/cli/commands/sync.py

@@ -0,0 +1,108 @@
+from datetime import datetime
+
+import click
+from pyproject_metadata import StandardMetadata
+
+import afterpython as ap
+from afterpython.utils import convert_author_name_to_id
+
+
+def _sync_authors_yml(authors: list[tuple[str, str | None]]):
+    """Sync authors.yml with authors in pyproject.toml"""
+    from afterpython.tools.myst import update_authors_yml
+    from afterpython._io.yaml import read_yaml
+
+    # read myst.yml from docs path to get "version"
+    doc_myst_yml = read_yaml(ap.paths.afterpython_path / "doc" / "myst.yml")
+    data = {
+        "version": doc_myst_yml["version"],
+        "project": {
+            "contributors": [
+                # NOTE: author is a tuple of (name, email), so author[0] is the name and author[1] is the email
+                {
+                    "id": convert_author_name_to_id(str(author[0])),
+                    "name": str(author[0]),
+                    "email": str(author[1]),
+                    # "github": ...
+                }
+                for author in authors
+            ]
+        },
+    }
+    update_authors_yml(data)
+    click.echo("✓ Synced authors.yml with pyproject.toml")
+
+
+@click.command()
+def sync():
+    """Sync between pyproject.toml+afterpython.toml and authors.yml+myst.yml files"""
+    from afterpython.const import CONTENT_TYPES
+    from afterpython.tools._afterpython import read_afterpython
+    from afterpython.tools.pyproject import read_metadata
+    from afterpython._io.toml import _from_tomlkit
+    from afterpython.tools.myst import update_myst_yml
+
+    pyproject: StandardMetadata = read_metadata()
+    project_name = str(pyproject.name)
+    afterpython = read_afterpython()
+    github_url = str(pyproject.urls.get("repository", ""))
+    company_name = str(_from_tomlkit(afterpython["company"]).get("name", ""))
+    company_url = str(_from_tomlkit(afterpython["company"]).get("url", ""))
+    website_url = str(_from_tomlkit(afterpython["website"]).get("url", ""))
+    authors = pyproject.authors
+    nav_bar = [
+        {
+            "title": content_type.capitalize() + "s",
+            "url": f"{website_url}/{content_type}",
+        }
+        if website_url
+        else ""
+        for content_type in CONTENT_TYPES
+    ]
+
+    _sync_authors_yml(authors)
+
+    # update myst.yml files for each content type (e.g. doc/, blog/, tutorial/, example/, guide/)
+    # based on the current values in pyproject.toml and afterpython.toml
+    for content_type in CONTENT_TYPES:
+        path = ap.paths.afterpython_path / content_type
+        nav_bar_per_content_type = [
+            item for item in nav_bar if item["title"] != content_type.capitalize()
+        ]
+        title = project_name + f"'s {content_type.capitalize()}"
+        data = {
+            "project": {
+                # using author ids defined in authors.yml
+                "authors": [
+                    convert_author_name_to_id(str(author[0])) for author in authors
+                ],
+                "venue": {
+                    # NOTE: company's name is used as the venue title
+                    "title": company_name,
+                    "url": company_url,
+                },
+                "copyright": f"© {company_name or project_name} {datetime.now().year}. All rights reserved.",
+                "title": "",
+                "description": str(pyproject.description),
+                "keywords": list(map(str, pyproject.keywords)),
+                "github": github_url,
+            },
+            "site": {
+                "title": title,
+                "options": {
+                    "logo_text": project_name,
+                    "logo_url": website_url,
+                },
+                "nav": nav_bar_per_content_type,
+                "actions": [
+                    {
+                        "title": "⭐ Star",
+                        "url": github_url,
+                    }
+                ],
+            },
+        }
+        update_myst_yml(data, path)
+        click.echo(
+            f"✓ Synced myst.yml in {path.name}/ with pyproject.toml and afterpython.toml"
+        )

afterpython/cli/commands/update.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from afterpython._typing import NodeEnv
+    from afterpython.pcu import Dependencies
+
+import subprocess
+import shutil
+
+import click
+from click.exceptions import Exit
+
+
+@click.group()
+def update():
+    """Update website template, pyproject.toml dependencies, etc."""
+    pass
+
+
+@update.command()
+@click.option(
+    "-u",
+    "--upgrade",
+    is_flag=True,
+    help="if enabled, the dependencies will be upgraded to the latest version",
+)
+@click.option(
+    "--all",
+    is_flag=True,
+    help="update all versions in dependencies and tool configurations (e.g. pre-commit-config.yaml)",
+)
+def dependencies(upgrade: bool, all: bool):
+    """Update pyproject.toml dependencies to the latest version"""
+    from afterpython.pcu import get_dependencies, update_dependencies
+    from afterpython.utils import has_uv
+
+    dependencies: Dependencies = get_dependencies()
+    has_at_least_one_update = False
+    for dep_type in dependencies:
+        if not len(dependencies[dep_type]):
+            continue
+        click.echo(f"- {dep_type} package(s):")
+        # category = extras or group name
+        for category, deps in dependencies[dep_type].items():
+            if dep_type in ["dependencies", "build-system"]:
+                category_name = ""
+            elif dep_type == "optional-dependencies":
+                category_name = f"extras: {category}"
+            elif dep_type == "dependency-groups":
+                category_name = f"group: {category}"
+            else:
+                raise ValueError(f"Invalid dependency type: {dep_type}")
+            for dep in deps:
+                msg = f"  {dep.requirement.name}: {dep.min_version}"
+                has_update = dep.min_version != dep.latest_version
+                if has_update:
+                    has_at_least_one_update = True
+                    msg += (
+                        f" → {click.style(dep.latest_version, fg='green', bold=True)}"
+                    )
+                if category_name:
+                    msg += f" ({category_name})"
+                click.echo(msg)
+    if not has_at_least_one_update:
+        click.echo(f"\n{click.style('No dependencies to update.', bold=True)}")
+        return
+    if has_at_least_one_update and upgrade:
+        update_dependencies(dependencies)  # write the latest versions to pyproject.toml
+        if has_uv():
+            click.echo("Upgrading dependencies with uv...")
+            result = subprocess.run(["uv", "lock"], check=False)
+            if result.returncode != 0:
+                raise Exit(result.returncode)
+            result = subprocess.run(
+                ["uv", "sync", "--all-extras", "--all-groups"], check=False
+            )
+            if result.returncode != 0:
+                raise Exit(result.returncode)
+            click.echo(
+                click.style(
+                    "✓ All dependencies upgraded successfully 🎉", fg="green", bold=True
+                )
+            )
+        else:
+            click.echo(
+                "uv not found. Updated pyproject.toml only (packages not installed)."
+            )
+    if all:
+        subprocess.run(["ap", "pre-commit", "autoupdate"])
+        click.echo("All pre-commit hooks updated successfully.")
+
+
+update.add_command(dependencies, name="deps")  # alias for "dependencies"
+
+
+@update.command()
+@click.pass_context
+@click.option(
+    "--no-backup",
+    is_flag=True,
+    help="if enabled, the existing project website template will not be backed up",
+)
+def website(ctx, no_backup: bool):
+    """Update the project website template to the latest version"""
+    from afterpython.utils import find_node_env
+
+    website_template_repo = "AfterPythonOrg/project-website-template"
+
+    paths = ctx.obj["paths"]
+    website_path = paths.website_path
+    if not no_backup:
+        backup_path = website_path.parent / "_website.backup"
+        if backup_path.exists():
+            click.echo(f"Removing old backup at {backup_path}...")
+            shutil.rmtree(backup_path)
+        if website_path.exists():
+            click.echo(f"Creating backup at {backup_path}...")
+            shutil.copytree(
+                website_path,
+                backup_path,
+                ignore=shutil.ignore_patterns("node_modules", ".svelte-kit"),
+            )
+
+    # Remove old template (but keep node_modules for faster reinstall)
+    if website_path.exists():
+        click.echo("Removing old project website template...")
+        shutil.rmtree(website_path)
+    website_path.mkdir(parents=True, exist_ok=True)
+
+    try:
+        click.echo("Updating the project website template...")
+        node_env: NodeEnv = find_node_env()
+        result = subprocess.run(
+            ["pnpx", "degit", website_template_repo, str(website_path)],
+            env=node_env,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise Exit(result.returncode)
+        result = subprocess.run(
+            ["pnpm", "install"], cwd=website_path, env=node_env, check=False
+        )
+        if result.returncode != 0:
+            raise Exit(result.returncode)
+    except Exception as e:
+        click.echo(f"✗ Error updating project website template: {e}", err=True)
+        if not no_backup:
+            click.echo("Restoring from backup...")
+            if website_path.exists():
+                shutil.rmtree(website_path)
+            shutil.copytree(backup_path, website_path)
+        raise

afterpython/cli/main.py

@@ -0,0 +1,71 @@
+import os
+import subprocess
+
+import click
+from trogon import tui
+from dotenv import load_dotenv, find_dotenv
+
+import afterpython as ap
+from afterpython import __version__
+from afterpython.cli.commands.init import init
+from afterpython.cli.commands.build import build
+from afterpython.cli.commands.dev import dev
+from afterpython.cli.commands.update import update
+from afterpython.cli.commands.check import check
+from afterpython.cli.commands.install import install
+from afterpython.cli.commands.format import format
+from afterpython.cli.commands.sync import sync
+from afterpython.cli.commands.start import start, doc, blog, tutorial, example, guide
+from afterpython.cli.commands.preview import preview
+from afterpython.cli.commands.clean import clean
+from afterpython.cli.commands.pre_commit import pre_commit
+from afterpython.cli.commands.commitizen import commitizen
+from afterpython.cli.commands.commit import commit
+from afterpython.cli.commands.bump import bump
+from afterpython.cli.commands.release import release
+
+
+@tui(command="tui", help="Open terminal UI")
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.pass_context
+@click.version_option(version=__version__)
+def afterpython_group(ctx):
+    """afterpython's CLI"""
+    load_dotenv(find_dotenv())  # Load environment variables from .env file
+    ctx.ensure_object(dict)
+    ctx.obj["paths"] = ap.paths
+
+    # Auto-sync before commands (except sync itself to avoid recursion)
+    if (
+        ctx.invoked_subcommand
+        and ctx.invoked_subcommand not in ["sync", "init"]
+        and os.getenv("AP_AUTO_SYNC", "0") == "1"
+    ):
+        click.echo("Auto-syncing...")
+        subprocess.run(["ap", "sync"])
+
+
+afterpython_group.add_command(init)
+afterpython_group.add_command(build)
+afterpython_group.add_command(dev)
+afterpython_group.add_command(update)
+afterpython_group.add_command(check)
+afterpython_group.add_command(format)
+afterpython_group.add_command(sync)
+afterpython_group.add_command(start)
+afterpython_group.add_command(install)
+afterpython_group.add_command(doc)
+afterpython_group.add_command(blog)
+afterpython_group.add_command(tutorial)
+afterpython_group.add_command(example)
+afterpython_group.add_command(guide)
+afterpython_group.add_command(preview)
+afterpython_group.add_command(clean)
+afterpython_group.add_command(pre_commit)
+afterpython_group.add_command(pre_commit, name="pc")
+afterpython_group.add_command(pre_commit, name="precommit")
+afterpython_group.add_command(commitizen)
+afterpython_group.add_command(commitizen, name="cz")
+afterpython_group.add_command(commit)
+afterpython_group.add_command(bump)
+afterpython_group.add_command(release)

afterpython/const.py

@@ -0,0 +1,5 @@
+from afterpython._typing import tContentType
+
+
+NODEENV_VERSION = "24.11.0"
+CONTENT_TYPES: list[tContentType] = ["doc", "blog", "tutorial", "example", "guide"]

afterpython/cz.toml

@@ -0,0 +1,27 @@
+[tool.commitizen]
+name = "cz_conventional_commits"
+# name = "cz_customize"
+tag_format = "v$version"
+version_scheme = "pep440"
+version_provider = "uv"
+update_changelog_on_bump = false
+major_version_zero = true
+
+# FIXME: commitizen can't even add a few custom types like "chore" and "wip", skip it for now
+# [[tool.commitizen.customize.questions]]
+# type = "list"
+# name = "change_type"
+# choices = [
+#     {value = "fix", name = "fix: A bug fix. Correlates with PATCH in SemVer"},
+#     {value = "feat", name = "feat: A new feature. Correlates with MINOR in SemVer"},
+#     {value = "docs", name = "docs: Documentation only changes"},
+#     {value = "style", name = "style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)"},
+#     {value = "refactor", name = "refactor: A code change that neither fixes a bug nor adds a feature"},
+#     {value = "perf", name = "perf: A code change that improves performance"},
+#     {value = "test", name = "test: Adding missing or correcting existing tests"},
+#     {value = "build", name = "build: Changes that affect the build system or external dependencies (example scopes: pip, docker, npm)"},
+#     {value = "ci", name = "ci: Changes to CI configuration files and scripts (example scopes: GitLabCI)"},
+#     {value = "chore", name = "chore: Other changes that don't modify src or test files"},
+#     {value = "wip", name = "wip: Work in progress"}
+# ]
+# message = "Select the type of change you are committing"

afterpython/main.py

@@ -0,0 +1,25 @@
+# import atexit
+
+from afterpython.cli import afterpython_group
+
+
+def exit_cli():
+    """Application Exitpoint."""
+    print("Cleanup actions here...")
+
+
+def run_cli() -> None:
+    """Application Entrypoint."""
+    # atexit.register(exit_cli)
+    afterpython_group(obj={})
+
+
+def run_pcu() -> None:
+    """Entrypoint for 'pcu' command (alias for 'ap update deps')."""
+    from afterpython.cli.commands.update import dependencies
+
+    dependencies()
+
+
+if __name__ == "__main__":
+    run_cli()