pyaether-cli 0.0.3__py3-none-any.whl

aether_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.3"

aether_cli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

aether_cli/build_process.py

@@ -0,0 +1,110 @@
+from pathlib import Path
+
+from aether import render
+from bs4 import BeautifulSoup
+from rich.console import Console
+
+from .utils import load_build_function_instance
+
+
+def _update_paths_in_soup(
+    console: Console,
+    soup: BeautifulSoup,
+    prefix: str,
+    static_assets_dir: Path,
+    static_css_dir: Path,
+    static_js_dir: Path,
+    output_dir: Path,
+    verbose: bool = False,
+) -> BeautifulSoup:
+    if verbose:
+        console.print("Updating paths in HTML...")
+
+    # Update link, img, script & a tags
+    for tag_name, attribute in [
+        ("link", "href"),
+        ("img", "src"),
+        ("script", "src"),
+        ("a", "href"),
+    ]:
+        for tag in soup.find_all(tag_name):
+            if attribute in tag.attrs:
+                if not tag[attribute].startswith(("http://", "https://", "/")):
+                    old_path = Path(tag[attribute])
+                    if Path("styles") in old_path.parents:
+                        new_path = static_css_dir / old_path.relative_to("styles")
+                    elif Path("js_scripts") in old_path.parents:
+                        new_path = static_js_dir / old_path.relative_to("js_scripts")
+                    elif Path("assets") in old_path.parents:
+                        new_path = static_assets_dir / old_path.relative_to("assets")
+                    elif Path("public") in old_path.parents:
+                        new_path = output_dir / old_path.relative_to("public")
+                    elif ".css" in old_path.suffixes:
+                        new_path = static_css_dir / old_path.name
+                    else:
+                        # Note: Need to find a better way to handle pages condition. Right now, we are just shoving it in this else block.
+                        # Note: Assuming the stem in href is same as the page_name mentioned in the config.
+                        if ".html" in old_path.suffixes:
+                            new_path = output_dir / old_path.relative_to(".")
+                        else:
+                            new_path = output_dir / old_path.name
+
+                    new_path = new_path.relative_to(output_dir)
+                    if prefix:
+                        new_path = prefix / new_path
+
+                    if verbose:
+                        console.print(
+                            f"Updating {attribute}: {old_path} -> /{new_path}"
+                        )
+                    tag[attribute] = f"/{new_path}"
+
+    return soup
+
+
+def builder(
+    console: Console,
+    output_html_file_name: str,
+    output_dir: Path,
+    prefix: str,
+    file_target: Path,
+    function_target: str,
+    static_assets_dir: Path,
+    static_css_dir: Path,
+    static_js_dir: Path,
+    verbose: bool = False,
+) -> None:
+    if verbose:
+        console.print(
+            f"Loading build function instance for '{output_html_file_name}.html'..."
+        )
+    instance = load_build_function_instance(file_target, function_target)
+
+    if verbose:
+        console.print("Rendering HTML...")
+
+    rendered_html = render(instance())
+    soup = BeautifulSoup(rendered_html, "html.parser")
+    updated_soup = _update_paths_in_soup(
+        console=console,
+        soup=soup,
+        prefix=prefix,
+        output_dir=output_dir,
+        static_assets_dir=static_assets_dir,
+        static_css_dir=static_css_dir,
+        static_js_dir=static_js_dir,
+        verbose=verbose,
+    )
+
+    output_html_path = output_dir / output_html_file_name
+    if not output_html_path.parent.exists():
+        if verbose:
+            console.print(f"Creating routing directory: {output_html_path.parent}")
+
+        output_html_path.parent.mkdir(parents=True)
+
+    if verbose:
+        console.print("Writing final HTML to file...")
+
+    with open(output_html_path, "w", encoding="utf-8") as file:
+        file.write(updated_soup.decode(pretty_print=True, formatter="html5"))

aether_cli/cli.py

@@ -0,0 +1,197 @@
+import shutil
+import signal
+import threading
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.table import Table
+
+from . import __version__
+from .build_process import builder
+from .configs import configs
+from .run_server import tcp_server
+from .utils import get_local_ip
+
+
+@click.group()
+def main() -> None:
+    pass
+
+
+@main.command()
+def version():
+    console = Console()
+    console.print(f"Aether CLI version: [green]{__version__}[/green]")
+
+
+@main.command()
+@click.option(
+    "--prefix",
+    type=str,
+    default="",
+    help="Inject 'base_path' prefix in the generated HTML file.",
+)
+@click.option("--verbose", is_flag=True, help="Enable verbose mode to echo steps.")
+def build(prefix: str, verbose: bool) -> None:
+    console = Console()
+
+    def _create_dir_if_not_exists(directory: Path) -> None:
+        if not directory.exists():
+            if verbose:
+                console.print(f"Creating directory: {directory}")
+            directory.mkdir(parents=True)
+
+    _create_dir_if_not_exists(configs.build_config.output_dir)
+
+    static_dir = configs.build_config.output_dir / "static"
+    # _create_dir_if_not_exists(configs.build_config.output_dir)
+
+    static_css_dir = static_dir / "css"
+    _create_dir_if_not_exists(static_css_dir)
+
+    static_js_dir = static_dir / "js"
+    _create_dir_if_not_exists(static_js_dir)
+
+    static_assets_dir = static_dir / "assets"
+    _create_dir_if_not_exists(static_assets_dir)
+
+    def _copy_dir(src: Path | None, dest: Path, directory_name: str) -> None:
+        if src and src.exists():
+            if verbose:
+                console.print(f"Copying {directory_name} from {src} to {dest}")
+            shutil.copytree(src, dest, dirs_exist_ok=True)
+        else:
+            console.print(f"Project doesn't have a '{src}' directory.")
+
+    _copy_dir(configs.static_content_config.assets_dir, static_assets_dir, "assets")
+    _copy_dir(configs.static_content_config.styles_dir, static_css_dir, "styles")
+    _copy_dir(configs.static_content_config.js_scripts_dir, static_js_dir, "js_scripts")
+    _copy_dir(
+        configs.static_content_config.public_dir,
+        configs.build_config.output_dir,
+        "public",
+    )
+
+    if verbose:
+        console.print("Building Index HTML...")
+
+    builder(
+        console=console,
+        output_html_file_name="index.html",
+        output_dir=configs.build_config.output_dir,
+        prefix=prefix,
+        file_target=configs.build_config.index_page_file_target,
+        function_target=configs.build_config.index_page_function_target,
+        static_assets_dir=static_assets_dir,
+        static_css_dir=static_css_dir,
+        static_js_dir=static_js_dir,
+        verbose=verbose,
+    )
+
+    if configs.build_config.pages_file_targets:
+        if verbose:
+            console.print("Building Pages...")
+
+        for file_target, function_target, page_name in zip(
+            configs.build_config.pages_file_targets,
+            configs.build_config.pages_function_targets,
+            configs.build_config.pages_names,
+            strict=False,
+        ):
+            builder(
+                console=console,
+                output_html_file_name=f"{page_name}.html",
+                output_dir=configs.build_config.output_dir,
+                prefix=prefix,
+                file_target=file_target,
+                function_target=function_target,
+                static_assets_dir=static_assets_dir,
+                static_css_dir=static_css_dir,
+                static_js_dir=static_js_dir,
+                verbose=verbose,
+            )
+
+    console.print("\n[bold green]Build successful![/bold green]")
+
+
+@main.command()
+def run() -> None:
+    console = Console()
+    interrupt_event = threading.Event()
+
+    if not configs.build_config.output_dir.exists():
+        console.print("[bold red]Build directory not found.[/bold red]")
+        console.print("Please run 'pytempl-cli build' first.")
+        return
+
+    try:
+        server = tcp_server(
+            console=console,
+            host=configs.run_config.host,
+            port=configs.run_config.port,
+            directory_path=configs.build_config.output_dir,
+        )
+    except OSError:
+        console.print(
+            f"[bold red]Error: Could not bind to address http://{configs.run_config.host if configs.run_config.host is not None else '127.0.0.1'}:{configs.run_config.port}.[/bold red]"
+        )
+        console.print(f"Is port {configs.run_config.port} already in use?")
+        return
+
+    def shutdown_handler(signum, _frame):
+        """Gracefully shut down the server."""
+        signal_name = signal.Signals(signum).name
+        console.print(
+            f"\n[bold yellow]Received {signal_name}. Shutting down server...[/bold yellow]"
+        )
+
+        server.shutdown()
+        interrupt_event.set()
+
+    # original_sigint = signal.getsignal(signal.SIGINT)
+    # original_sigterm = signal.getsignal(signal.SIGTERM)
+
+    signal.signal(signal.SIGINT, shutdown_handler)
+    signal.signal(signal.SIGTERM, shutdown_handler)
+
+    with Live(
+        Spinner("dots", text=" Starting server..."), console=console, transient=True
+    ):
+        server_thread = threading.Thread(target=server.serve_forever)
+        server_thread.daemon = True
+        server_thread.start()
+
+    info_table = Table.grid(padding=(0, 1))
+    info_table.add_column()
+    info_table.add_column()
+
+    info_table.add_row("✓", "[bold green]Aether App[/bold green] is running!")
+    info_table.add_row(
+        "  ",
+        f"[cyan]Local:[/cyan]      http://{configs.run_config.host if configs.run_config.host is not None else '127.0.0.1'}:{configs.run_config.port}",
+    )
+
+    local_ip = get_local_ip()
+    if local_ip:
+        info_table.add_row(
+            "  ",
+            f"[cyan]Network:[/cyan]    http://{local_ip}:{configs.run_config.port}",
+        )
+
+    console.print(info_table)
+    console.print("\nPress CTRL+C to stop the server.\n")
+
+    try:
+        interrupt_event.wait()
+    finally:
+        # --- Cleanup: Restore original signal handlers ---
+        console.print("[bold red]Server has been shut down.[/bold red]")
+        signal.signal(signal.SIGINT, signal.getsignal(signal.SIGINT))
+        signal.signal(signal.SIGTERM, signal.getsignal(signal.SIGTERM))
+
+
+if __name__ == "__main__":
+    main()

aether_cli/configs.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+from typing import Self
+
+from pydantic import BaseModel, model_validator
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    import tomli as tomllib  # type: ignore[import]
+
+
+class BuildConfig(BaseModel):
+    index_page_file_target: Path
+    index_page_function_target: str
+
+    output_dir: Path
+
+    pages_file_targets: list[Path]
+    pages_function_targets: list[str]
+    pages_names: list[str]
+
+    @model_validator(mode="after")
+    def validate_attrs(self) -> Self:
+        if len(self.pages_file_targets) != len(self.pages_function_targets):
+            raise ValueError(
+                "Each 'pages_file_target' must have a corresponding 'pages_function_target'."
+            )
+        if len(self.pages_file_targets) != len(self.pages_names):
+            raise ValueError(
+                "Each 'pages_file_target' must have a corresponding 'pages_name'."
+            )
+
+        return self
+
+
+class RunConfig(BaseModel):
+    host: str | None
+    port: int
+
+
+class StaticContentConfig(BaseModel):
+    assets_dir: Path | None
+    js_scripts_dir: Path | None
+    public_dir: Path | None
+    styles_dir: Path | None
+
+
+class Config(BaseModel):
+    build_config: BuildConfig
+    run_config: RunConfig
+    static_content_config: StaticContentConfig
+
+
+def load_configs() -> Config:
+    pyproject_file = Path("pyproject.toml")
+    if not pyproject_file.exists():
+        raise FileNotFoundError("Unable to locate configuration file.")
+
+    with open(pyproject_file, "rb") as file:
+        raw_aether_config: dict = tomllib.load(file).get("tool", {}).get("aether", {})
+
+        raw_aether_build_config: dict = raw_aether_config.get("build", {})
+        raw_aether_run_config: dict = raw_aether_config.get("run", {})
+        raw_aether_static_content_config: dict = raw_aether_config.get(
+            "static_content", {}
+        )
+
+    # Decompose raw 'build' configurations.
+    # TODO: Add fallbacks/defaults if the lengths of file_targets and function_targets are different
+    parsed_build_config = BuildConfig(
+        index_page_file_target=raw_aether_build_config.get("index_page", {}).get(
+            "file_target", "main.py"
+        ),
+        index_page_function_target=raw_aether_build_config.get("index_page", {}).get(
+            "function_target", "main"
+        ),
+        output_dir=raw_aether_build_config.get("output_dir", "build/"),
+        pages_file_targets=raw_aether_build_config.get("pages", {}).get(
+            "file_targets", []
+        ),
+        pages_function_targets=raw_aether_build_config.get("pages", {}).get(
+            "function_targets", []
+        ),
+        pages_names=raw_aether_build_config.get("pages", {}).get("names", []),
+    )
+
+    # Decompose raw 'run' configurations.
+    parsed_run_config = RunConfig(
+        host=raw_aether_run_config.get("host", None),
+        port=raw_aether_run_config.get("port", 8080),
+    )
+
+    # Decompose raw 'static content' configurations.
+    parsed_static_content_config = StaticContentConfig(
+        assets_dir=raw_aether_static_content_config.get("assets_dir"),
+        js_scripts_dir=raw_aether_static_content_config.get("js_scripts_dir"),
+        public_dir=raw_aether_static_content_config.get("public_dir"),
+        styles_dir=raw_aether_static_content_config.get("styles_dir"),
+    )
+
+    return Config(
+        build_config=parsed_build_config,
+        run_config=parsed_run_config,
+        static_content_config=parsed_static_content_config,
+    )
+
+
+configs = load_configs()

aether_cli/run_server.py

@@ -0,0 +1,44 @@
+import http.server
+import socketserver
+from datetime import datetime
+from pathlib import Path
+
+from rich.console import Console
+
+
+def request_handler(console: Console, directory_path: str):
+    class RichHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, directory=directory_path, **kwargs)
+
+        def log_message(self, format, *args):
+            status_code = args[1]
+            request_line = args[0]
+
+            if status_code.startswith("2"):
+                status_color = "green"
+            elif status_code.startswith("3"):
+                status_color = "yellow"
+            else:
+                status_color = "red"
+
+            timestamp = f"[[dim]{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}[/dim]]"
+
+            console.print(
+                f"{timestamp} INFO:\t"
+                f'{self.address_string()} - "{request_line}" '
+                f"[{status_color}]{status_code}[/{status_color}]"
+            )
+
+    return RichHTTPRequestHandler
+
+
+def tcp_server(
+    console: Console, host: str | None, port: int, directory_path: Path
+) -> socketserver.TCPServer:
+    handler_factory = request_handler(console, str(directory_path))
+
+    if host is None:
+        host = ""
+
+    return socketserver.TCPServer((host, port), handler_factory)

aether_cli/utils.py

@@ -0,0 +1,50 @@
+import importlib
+import importlib.util
+import socket
+import sys
+from pathlib import Path
+from typing import Any
+
+
+class ImportFromStringError(Exception):
+    pass
+
+
+def load_build_function_instance(file_target: str, function_target: str) -> Any:
+    working_dir = Path.cwd()
+    working_file = Path(file_target)
+
+    if not working_file.exists():
+        raise FileNotFoundError(f"File '{file_target}' not found.")
+
+    module_path = working_dir / file_target
+    module_name = Path(file_target).stem
+
+    sys.path.append(str(working_dir))
+
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    if spec and spec.loader:
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    else:
+        raise ImportFromStringError(
+            f"Could not import module from path '{module_path}'"
+        )
+
+    try:
+        instance = getattr(module, function_target)
+    except AttributeError:
+        message = f'Attribute "{function_target}" not found in module "{module_name}".'
+        raise ImportFromStringError(message)
+
+    return instance
+
+
+def get_local_ip():
+    """Tries to find the local network IP address of the machine."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(("8.8.8.8", 80))
+            return s.getsockname()[0]
+    except Exception:
+        return None

pyaether_cli-0.0.3.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: pyaether-cli
+Version: 0.0.3
+Summary: A CLI to build and run dev server for Aether apps.
+Project-URL: homepage, https://github.com/pyaether/aether-cli
+Project-URL: repository, https://github.com/pyaether/aether-cli
+Project-URL: documentation, https://github.com/pyaether/aether-cli
+Author-email: Saurabh Ghanekar <ghanekarsaurabh8@gmail.com>
+License-Expression: BSD-2-Clause
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.13
+Requires-Dist: click>=8.1
+Requires-Dist: pyaether
+Requires-Dist: pydantic>=2.10
+Requires-Dist: rich>=13.9
+Requires-Dist: typing-extensions>=4
+Description-Content-Type: text/markdown
+
+# Aether CLI
+
+Build and run your Aether apps as well as manage your Altar UI components from the command line.

pyaether_cli-0.0.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+aether_cli/__init__.py,sha256=4GZKi13lDTD25YBkGakhZyEQZWTER_OWQMNPoH_UM2c,22
+aether_cli/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+aether_cli/build_process.py,sha256=4Dl-rM0O7RN2QzL0FHhBTxENSuv0yts-Q58sNkZWRQc,3874
+aether_cli/cli.py,sha256=H06Yu21EgkK-nHYfORC-LtLZXUTA2DVGdm5wDG9Pxuw,6377
+aether_cli/configs.py,sha256=5wSRoDEfvR-HxCfQoLB0-FhQJVnHVPf9vI0Y_6iEwUc,3506
+aether_cli/run_server.py,sha256=19700YKa6WPancZLIkvgpp4-dhECHtc4IEiwIRjXMto,1346
+aether_cli/utils.py,sha256=xKUvgSxp8oNddaTC7mlra_LDBqyUrOCiW7nFKiarJ-Y,1393
+pyaether_cli-0.0.3.dist-info/METADATA,sha256=Q-LOLSEw2H5Ll2gJxQeCykcxioqe6kKpev-UvyPYSmM,850
+pyaether_cli-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyaether_cli-0.0.3.dist-info/entry_points.txt,sha256=zbcg3c2Ry_eTiyEbTMGMAGnl_MpbS68oZ1q-Jm6rp-M,47
+pyaether_cli-0.0.3.dist-info/RECORD,,

pyaether_cli-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyaether_cli-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aether = aether_cli.cli:main