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

afterpython/__init__.py

@@ -0,0 +1,13 @@
+# import builtins
+# from pprint import pprint
+from importlib.metadata import version
+
+from afterpython._paths import Paths
+
+# make pprint available in the global namespace
+# builtins.pprint = pprint
+
+paths = Paths()
+
+__version__ = version("afterpython")
+__all__ = ("__version__", "paths")

afterpython/_io/toml.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from tomlkit.toml_document import TOMLDocument
+
+import tomlkit
+
+
+# VIBE-CODED
+def _from_tomlkit(value):
+    """Recursively convert tomlkit objects to plain Python data structures.
+
+    This ensures compatibility with other libraries (like ruamel.yaml):
+    - tomlkit containers → plain Python containers
+    - tomlkit primitives → plain Python primitives
+    """
+    from tomlkit.items import AoT, Array, InlineTable, Table
+
+    if value is None:
+        return None
+
+    # Check containers first (these are the problematic ones)
+    if isinstance(value, (Table, InlineTable)):
+        # tomlkit dict-like → plain dict
+        return {k: _from_tomlkit(v) for k, v in value.items()}
+    elif isinstance(value, (Array, AoT)):
+        # tomlkit array → plain list
+        return [_from_tomlkit(item) for item in value]
+    elif isinstance(value, dict):
+        # Already a dict, but recurse to handle nested tomlkit objects
+        return {k: _from_tomlkit(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        # Already a list, but recurse to handle nested tomlkit objects
+        return [_from_tomlkit(item) for item in value]
+
+    # Primitives - tomlkit primitives inherit from Python types
+    # Just convert explicitly to be safe
+    elif isinstance(value, bool):  # MUST check bool before int!
+        return bool(value)
+    elif isinstance(value, int):
+        return int(value)
+    elif isinstance(value, float):
+        return float(value)
+    elif isinstance(value, str):
+        return str(value)
+    else:
+        # datetime, date, time, or already plain Python type
+        return value
+
+
+# VIBE-CODED
+def _to_tomlkit(value):
+    """Recursively convert Python data structures to tomlkit objects.
+
+    This ensures proper TOML formatting:
+    - List of dicts → array of inline tables: [{key = val}]
+    - Nested dicts → nested tables with proper structure
+    """
+    from tomlkit import array, inline_table
+
+    if value is None:
+        return None
+
+    if isinstance(value, dict):
+        # Plain dict → recursively convert values
+        return {k: _to_tomlkit(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        if not value:
+            # Empty list → empty tomlkit array
+            return array()
+
+        # Check if ALL items are dicts (should be inline tables)
+        if all(isinstance(item, dict) for item in value):
+            arr = array()
+            for item in value:
+                tbl = inline_table()
+                # Recursively convert the dict values
+                tbl.update({k: _to_tomlkit(v) for k, v in item.items()})
+                arr.append(tbl)
+            return arr
+        else:
+            # Mixed or non-dict items → regular array
+            arr = array()
+            for item in value:
+                arr.append(_to_tomlkit(item))
+            return arr
+    else:
+        # Primitives (str, int, float, bool, datetime, etc.)
+        # tomlkit handles these natively
+        return value
+
+
+def read_toml(file_path: Path) -> TOMLDocument:
+    with open(file_path, "rb") as f:
+        data: TOMLDocument = tomlkit.parse(f.read())
+    return data
+
+
+def write_toml(file_path: Path, data: TOMLDocument | dict):
+    with open(file_path, "w") as f:
+        f.write(tomlkit.dumps(data))

afterpython/_io/yaml.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedMap
+
+
+def _get_yaml() -> YAML:
+    """Get configured YAML instance that preserves order, comments, and formatting"""
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.default_flow_style = False
+    yaml.width = 4096  # Prevent line wrapping
+    return yaml
+
+
+def read_yaml(file_path: Path) -> CommentedMap:
+    yaml = _get_yaml()
+    with open(file_path) as f:
+        return yaml.load(f)
+
+
+def write_yaml(file_path: Path, data: dict):
+    """Write YAML data"""
+    yaml = _get_yaml()
+    with open(file_path, "w") as f:
+        yaml.dump(data, f)

afterpython/_paths.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Paths:
+    package_path: Path = field(init=False)
+    templates_path: Path = field(init=False)
+    user_path: Path = field(init=False)
+    pyproject_path: Path = field(init=False)
+    afterpython_path: Path = field(init=False)
+    website_path: Path = field(init=False)
+    build_path: Path = field(init=False)
+    static_path: Path = field(init=False)
+
+    def __post_init__(self):
+        # package path is the path to the afterpython package in user's site-packages
+        self.package_path = Path(__file__).resolve().parents[0]
+        self.templates_path = self.package_path / "templates"
+        self.user_path = self._find_project_root()
+        self.pyproject_path = self.user_path / "pyproject.toml"
+        self.afterpython_path = self.user_path / "afterpython"
+        self.website_path = self.afterpython_path / "_website"
+        self.build_path = self.afterpython_path / "_build"
+        self.static_path = self.afterpython_path / "static"
+
+    def _find_project_root(self) -> Path:
+        """Find the project root by looking for pyproject.toml in current or parent directories."""
+        current = Path.cwd()
+
+        # Check current directory and all parents
+        for path in [current, *current.parents]:
+            if (path / "pyproject.toml").exists():
+                return path
+
+        # If no pyproject.toml found, raise an error like uv does
+        raise FileNotFoundError(
+            "No pyproject.toml found in current directory or any parent directory"
+        )

afterpython/_typing.py

@@ -0,0 +1,4 @@
+from typing import Literal, TypeAlias
+
+NodeEnv: TypeAlias = dict[str, str]
+tContentType = Literal["doc", "blog", "tutorial", "example", "guide"]

afterpython/builders/__init__.py

@@ -0,0 +1,17 @@
+from afterpython.builders.content_json import build_content_json
+from afterpython.builders.index_md import (
+    create_placeholder_index_md_files,
+    delete_placeholder_index_md_files,
+)
+from afterpython.builders.jupyter_notebook import build_jupyter_notebooks
+from afterpython.builders.markdown import build_markdown
+from afterpython.builders.metadata import build_metadata
+
+__all__ = (
+    "build_content_json",
+    "build_jupyter_notebooks",
+    "build_markdown",
+    "build_metadata",
+    "create_placeholder_index_md_files",
+    "delete_placeholder_index_md_files",
+)

afterpython/builders/content_json.py

@@ -0,0 +1,131 @@
+"""
+Build {content_type}.json for non-doc content type (blog, tutorial, example, guide)
+
+Combines all individual content JSON files from MyST build output into a single
+manifest file for SvelteKit to consume (e.g., blog.json, tutorial.json).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from afterpython._typing import tContentType
+
+import json
+from pathlib import Path
+
+import click
+
+import afterpython as ap
+from afterpython.const import CONTENT_TYPES
+
+
+def standardize_data(content_type: tContentType, content: dict) -> dict:
+    """
+    Standardize the content dictionary to a single level.
+    """
+    from afterpython.tools._afterpython import read_afterpython
+
+    afterpython = read_afterpython()
+    website = afterpython.get("website", {})
+    content_type_config = website.get(content_type, {})
+    featured_post = content_type_config.get("featured_post", "")
+
+    frontmatter = content.get("frontmatter", {})
+    # e.g. featured_post = "blog4.md" or "blog4"
+    is_featured = content["slug"] == featured_post or content["location"].endswith(
+        featured_post
+    )
+    return {
+        "version": content["version"],
+        "slug": content["slug"],
+        "location": content["location"],
+        "featured": is_featured,
+        # frontmatter fields
+        "title": frontmatter.get("title", ""),
+        "description": frontmatter.get("description", ""),
+        "tags": frontmatter.get("tags", []),
+        "date": frontmatter.get("date", ""),
+        "thumbnail": frontmatter.get("thumbnail", ""),
+        "thumbnailOptimized": frontmatter.get("thumbnailOptimized", ""),
+        "authors": frontmatter.get("authors", []),
+    }
+
+
+def convert_paths(content_type: tContentType, output_file: Path):
+    """
+    Convert paths (generated by MyST build) in the content_json file to use the new paths in the build output.
+    e.g. convert /blog_thumbnail-08d4f63a34eb7b55b6a00c25218c3295.png to /blog/build/blog_thumbnail-08d4f63a34eb7b55b6a00c25218c3295.png
+    """
+    with open(output_file, encoding="utf-8") as f:
+        content = json.load(f)
+
+    for item in content:
+        if not item.get("thumbnailOptimized"):
+            item["thumbnailOptimized"] = item["thumbnail"]
+        item["thumbnail"] = f"/{content_type}/build" + item["thumbnail"]
+        item["thumbnailOptimized"] = (
+            f"/{content_type}/build" + item["thumbnailOptimized"]
+        )
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(content, f, indent=2, ensure_ascii=False)
+
+    click.echo(f"Completed path conversion in {output_file}")
+
+
+def build_content_json():
+    """Build {content_type}.json manifest for non-doc content types.
+
+    Reads all JSON files from afterpython/_build/{content_type}/site/content/
+    (excluding index.json) and combines them into a single manifest file at
+    afterpython/_build/{content_type}.json.
+
+    This manifest is used by SvelteKit landing pages to list all content items.
+
+    Args:
+        content_type: Content type (blog, tutorial, example, guide)
+    """
+    for content_type in CONTENT_TYPES:
+        if content_type == "doc":
+            continue  # Doc doesn't need a combined manifest
+
+        content_path = ap.paths.afterpython_path / content_type
+        content_dir = content_path / "_build" / "site" / "content"
+        myst_yml_path = content_path / "myst.yml"
+        if (
+            not content_path.exists()
+            or not myst_yml_path.exists()
+            or not content_dir.exists()
+        ):
+            click.echo(f"Skipping {content_type}.json (missing files)")
+            continue
+
+        click.echo(f"Building {content_type}.json...")
+
+        # Collect all JSON files except index.json, which is created by a placeholder index.md file
+        content_items = []
+        for json_file in content_dir.glob("*.json"):
+            if json_file.stem == "index":
+                continue  # Skip index.json
+
+            try:
+                with open(json_file, encoding="utf-8") as f:
+                    data = json.load(f)
+
+                # Preserve all data from MyST JSON files
+                # The project-website-template will parse the fields it needs
+                content_items.append(standardize_data(content_type, data))
+            except (json.JSONDecodeError, KeyError) as e:
+                click.echo(f"Warning: Failed to parse {json_file}: {e}")
+                continue
+
+        # Write combined manifest
+        output_file = ap.paths.build_path / f"{content_type}.json"
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(content_items, f, indent=2, ensure_ascii=False)
+
+        click.echo(f"Generated {output_file} with {len(content_items)} items")
+
+        convert_paths(content_type, output_file)

afterpython/builders/index_md.py

@@ -0,0 +1,94 @@
+import click
+
+import afterpython as ap
+from afterpython.const import CONTENT_TYPES
+
+
+def create_placeholder_index_md_files():
+    """Create placeholder index.md files for non-doc content types.
+
+    Without these placeholders, MyST treats the first file in TOC as index,
+    causing it to use routes like /blog instead of /blog/blog1. These routes
+    are reserved for SvelteKit landing pages. Placeholders ensure all actual
+    content files get proper slugs and are deleted post-build.
+    """
+    from afterpython._io.yaml import read_yaml, write_yaml
+    from afterpython.tools.myst import _write_index_file
+
+    for content_type in CONTENT_TYPES:
+        if content_type == "doc":
+            continue  # Doc doesn't need a placeholder index.md
+
+        content_path = ap.paths.afterpython_path / content_type
+        if not content_path.exists():
+            click.echo(
+                f"No content found in {content_path}, skip creating placeholder index.md"
+            )
+            continue
+
+        myst_yml_path = content_path / "myst.yml"
+        if not myst_yml_path.exists():
+            click.echo(
+                f"No myst.yml found in {content_path}, skip creating placeholder index.md"
+            )
+            continue
+
+        content_path = ap.paths.afterpython_path / content_type
+        myst_yml_path = content_path / "myst.yml"
+
+        # Prepend index.md to TOC in myst.yml
+        if myst_yml_path.exists():
+            # Create placeholder index.md file
+            _write_index_file(content_type)
+            myst_data = read_yaml(myst_yml_path) or {}
+            toc = myst_data.get("project", {}).get("toc", [])
+
+            # Check if index.md is already first in TOC
+            if not toc or toc[0].get("file") != "index.md":
+                # Prepend index.md to TOC in myst.yml
+                new_toc = [{"file": "index.md"}, *toc]
+                if "project" not in myst_data:
+                    myst_data["project"] = {}
+                myst_data["project"]["toc"] = new_toc
+                write_yaml(myst_yml_path, myst_data)
+                click.echo(f"Added index.md to TOC in {myst_yml_path}")
+
+
+def delete_placeholder_index_md_files():
+    """Delete placeholder index.md and built index.html for non-doc content types.
+
+    These files were created pre-build to ensure proper slug generation. Now that
+    MyST has built the content with correct slugs, we delete them so SvelteKit
+    can own the landing page routes (/blog, /tutorial, etc.) in the project website.
+    """
+    from afterpython._io.yaml import read_yaml, write_yaml
+
+    for content_type in CONTENT_TYPES:
+        if content_type == "doc":
+            continue  # Doc doesn't need a placeholder index.md
+
+        content_path = ap.paths.afterpython_path / content_type
+        myst_yml_path = content_path / "myst.yml"
+        index_md = content_path / "index.md"
+
+        # Delete index.md from source
+        if index_md.exists():
+            index_md.unlink()
+            click.echo(f"Deleted: {index_md}")
+
+        # Delete index.html from build output
+        index_html = content_path / "_build" / "html" / "index.html"
+        if index_html.exists():
+            index_html.unlink()
+            click.echo(f"Deleted: {index_html}")
+
+        # Remove index.md from TOC in myst.yml
+        if myst_yml_path.exists():
+            myst_data = read_yaml(myst_yml_path) or {}
+            toc = myst_data.get("project", {}).get("toc", [])
+
+            # Remove index.md from TOC if it's the first entry
+            if toc and toc[0].get("file") == "index.md":
+                myst_data["project"]["toc"] = toc[1:]
+                write_yaml(myst_yml_path, myst_data)
+                click.echo(f"Removed index.md from TOC in {myst_yml_path}")