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

afterpython/cli/commands/start.py

@@ -0,0 +1,144 @@
+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,
+    ),
+    "hidden": True,  # Hide these commands from help output
+}
+
+
+@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):
+    """Start MyST development server for a specific content type"""
+    from afterpython.const import 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", "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,152 @@
+from datetime import datetime
+
+import click
+from pyproject_metadata import StandardMetadata
+from tomlkit.toml_document import TOMLDocument
+
+import afterpython as ap
+from afterpython.utils import convert_author_name_to_id, normalize_static_path
+
+
+def _sync_authors_yml(authors: list[tuple[str, str | None]]):
+    """Sync authors.yml with authors in pyproject.toml"""
+    from afterpython._io.yaml import read_yaml
+    from afterpython.tools.myst import update_authors_yml
+
+    # 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 configuration between pyproject.toml/afterpython.toml and authors.yml/myst.yml"""
+    from afterpython._io.toml import _from_tomlkit
+    from afterpython.const import CONTENT_TYPES
+    from afterpython.tools._afterpython import read_afterpython
+    from afterpython.tools.myst import update_myst_yml
+    from afterpython.tools.pyproject import (
+        read_metadata,
+        read_pyproject,
+        write_pyproject,
+    )
+
+    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.get("company", {})).get("name", ""))
+    company_url = str(_from_tomlkit(afterpython.get("company", {})).get("url", ""))
+    website_url = str(_from_tomlkit(afterpython.get("website", {})).get("url", ""))
+    try:
+        website_favicon = normalize_static_path(
+            str(_from_tomlkit(afterpython.get("website", {})).get("favicon", ""))
+        )
+        website_logo = normalize_static_path(
+            str(_from_tomlkit(afterpython.get("website", {})).get("logo", ""))
+        )
+        website_logo_dark = normalize_static_path(
+            str(_from_tomlkit(afterpython.get("website", {})).get("logo_dark", ""))
+        )
+        website_thumbnail = normalize_static_path(
+            str(_from_tomlkit(afterpython.get("website", {})).get("thumbnail", ""))
+        )
+    except ValueError as e:
+        click.echo(f"Error in reading afterpython.toml: {e}")
+        return
+
+    authors = pyproject.authors
+    if company_name and company_url:
+        nav_bar = [{"title": company_name, "url": company_url}]
+    else:
+        nav_bar = []
+    if website_url:
+        nav_bar.extend(
+            [
+                {
+                    "title": content_type.capitalize() + "s",
+                    "url": f"{website_url}/{content_type}",
+                }
+                for content_type in CONTENT_TYPES
+            ]
+        )
+
+    _sync_authors_yml(authors)
+
+    # update "homepage", "repository", and "documentation" in pyproject.toml
+    if website_url:
+        doc: TOMLDocument = read_pyproject()
+        doc["project"]["urls"]["homepage"] = website_url
+        doc["project"]["urls"]["documentation"] = f"{website_url}/doc"
+        write_pyproject(doc)
+
+    # 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() + "s"
+        # ]
+        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,
+                "thumbnail": "../static" + website_thumbnail
+                if website_thumbnail
+                else "",
+            },
+            "site": {
+                "title": title,
+                "options": {
+                    "favicon": "../static" + website_favicon if website_favicon else "",
+                    "logo": "../static" + website_logo if website_logo else "",
+                    "logo_dark": "../static" + website_logo_dark
+                    if website_logo_dark
+                    else "",
+                    "logo_text": project_name,
+                    "logo_url": website_url,
+                },
+                # FIXME: disable nav bar for now until myst fixes the issue with the nav bar
+                # the current issue is they prepend the BASE_URL to the nav bar links even they are external
+                # "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,176 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from afterpython._typing import NodeEnv
+    from afterpython.pcu import Dependencies
+
+import shutil
+import subprocess
+
+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="Upgrade dependencies to their latest versions",
+)
+@click.option(
+    "--all",
+    is_flag=True,
+    help="Also update pre-commit hooks and pixi dependencies",
+)
+def dependencies(upgrade: bool, all: bool):
+    """Check and update project dependencies to latest versions"""
+    from afterpython.pcu import get_dependencies, update_dependencies
+    from afterpython.utils import has_pixi, 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 in pyproject.toml 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.")
+        if has_pixi():
+            click.echo("Upgrading dependencies with pixi...")
+            result = subprocess.run(
+                ["pixi", "upgrade", "--exclude", "python"], check=False
+            )
+            if result.returncode != 0:
+                raise Exit(result.returncode)
+            result = subprocess.run(["pixi", "lock"], check=False)
+            if result.returncode != 0:
+                raise Exit(result.returncode)
+            result = subprocess.run(["pixi", "install"], check=False)
+            if result.returncode != 0:
+                raise Exit(result.returncode)
+            click.echo(
+                click.style(
+                    "✓ All dependencies in pixi.toml upgraded successfully 🎉",
+                    fg="green",
+                    bold=True,
+                )
+            )
+
+
+update.add_command(dependencies, name="deps")  # alias for "dependencies"
+
+
+@update.command()
+@click.pass_context
+@click.option(
+    "--no-backup",
+    is_flag=True,
+    help="Skip creating a backup of the existing website template",
+)
+def website(ctx, no_backup: bool):
+    """Update 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,132 @@
+import os
+import subprocess
+from collections import defaultdict
+
+import click
+from dotenv import find_dotenv, load_dotenv
+from trogon import tui
+
+import afterpython as ap
+from afterpython import __version__
+from afterpython.cli.commands.add import add
+from afterpython.cli.commands.build import build
+from afterpython.cli.commands.bump import bump
+from afterpython.cli.commands.check import check
+from afterpython.cli.commands.clean import clean
+from afterpython.cli.commands.commit import commit
+from afterpython.cli.commands.commitizen import commitizen
+from afterpython.cli.commands.dev import dev
+from afterpython.cli.commands.format import format
+from afterpython.cli.commands.init import init
+from afterpython.cli.commands.init_branch_rules import init_branch_rules
+from afterpython.cli.commands.install import install
+from afterpython.cli.commands.lock import lock
+from afterpython.cli.commands.pre_commit import pre_commit
+from afterpython.cli.commands.preview import preview
+from afterpython.cli.commands.release import release
+from afterpython.cli.commands.remove import remove
+from afterpython.cli.commands.start import blog, doc, example, guide, start, tutorial
+from afterpython.cli.commands.sync import sync
+from afterpython.cli.commands.update import update
+
+
+class AliasGroup(click.Group):
+    """Custom group that displays command aliases together."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._aliases = defaultdict(list)  # Maps primary command -> list of aliases
+        self._alias_to_primary = {}  # Maps alias -> primary command name
+
+    def add_command(self, cmd, name=None):
+        """Track aliases when the same command is added with different names."""
+        name = name or cmd.name
+
+        # Check if this command object was already added under a different name
+        for existing_name, existing_cmd in self.commands.items():
+            if existing_cmd is cmd and existing_name != name:
+                # This is an alias
+                self._aliases[existing_name].append(name)
+                self._alias_to_primary[name] = existing_name
+                break
+
+        super().add_command(cmd, name)
+
+    def format_commands(self, ctx, formatter):
+        """Format commands with aliases shown together."""
+        commands = []
+        for subcommand in self.list_commands(ctx):
+            # Skip aliases - they'll be shown with their primary command
+            if subcommand in self._alias_to_primary:
+                continue
+
+            cmd = self.get_command(ctx, subcommand)
+            if cmd is None:
+                continue
+
+            # Skip hidden commands
+            if cmd.hidden:
+                continue
+
+            help_text = cmd.get_short_help_str(limit=formatter.width)
+
+            # Build command name with aliases
+            aliases = self._aliases.get(subcommand, [])
+            if aliases:
+                subcommand = f"{subcommand}, {', '.join(aliases)}"
+
+            commands.append((subcommand, help_text))
+
+        if commands:
+            with formatter.section("Commands"):
+                formatter.write_dl(commands)
+
+
+@tui(command="tui", help="Open terminal UI")
+@click.group(cls=AliasGroup, 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(check, name="lint")
+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(commitizen)
+afterpython_group.add_command(commitizen, name="cz")
+afterpython_group.add_command(commit)
+afterpython_group.add_command(bump)
+afterpython_group.add_command(release)
+afterpython_group.add_command(init_branch_rules)
+afterpython_group.add_command(add)
+afterpython_group.add_command(remove)
+afterpython_group.add_command(lock)

afterpython/const.py

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

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()