pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/commands/utils.py

@@ -0,0 +1,42 @@
+import json
+from pathlib import Path
+from typing import Tuple, Dict, Any
+
+
+def resolve_package_metadata(
+    script_path: Path, cli_name: str | None
+) -> Tuple[str, Dict[str, Any]]:
+    """
+    Resolves the output artifact name and loads settings.json.
+    Prioritizes CLI name > settings.json title > script stem.
+    """
+    settings = {}
+    out_name = cli_name
+
+    # 1. Load settings.json if exists
+    try:
+        settings_path = script_path.parent / "settings.json"
+        if settings_path.exists():
+            settings = json.loads(settings_path.read_text())
+    except Exception:
+        # If settings are malformed, we just proceed with empty settings
+        pass
+
+    # 2. Resolve Name
+    if not out_name:
+        # Try metadata title
+        title = settings.get("title")
+        if title:
+            # Sanitize title
+            out_name = "".join(
+                c if c.isalnum() or c in ("-", "_") else "_" for c in title
+            )
+            while "__" in out_name:
+                out_name = out_name.replace("__", "_")
+            out_name = out_name.strip("_")
+
+    if not out_name:
+        # Fallback to script stem (e.g. 'app')
+        out_name = script_path.stem
+
+    return out_name, settings

pytron/commands/workflow.py

@@ -0,0 +1,95 @@
+import argparse
+from pathlib import Path
+from ..console import log, console, print_rule
+
+WORKFLOW_TEMPLATE = r"""name: Package App (Multi-Platform)
+
+on:
+  push:
+    tags:
+      - 'v*' # Trigger on version tags like v1.0.0
+  workflow_dispatch: # Allow manual trigger
+
+jobs:
+  package:
+    name: Build for ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest]
+        python-version: ["3.11"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Linux Dependencies
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-0 libgtk-3-dev
+
+      - name: Install Pytron & Dependencies
+        run: |
+          pip install pytron-kit
+          pytron install
+
+      - name: Build and Package
+        run: pytron package --smart-assets --installer
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: pytron-build-${{ matrix.os }}
+          path: dist/
+"""
+
+
+def cmd_workflow(args: argparse.Namespace) -> int:
+    if args.workflow_command == "init":
+        return cmd_workflow_init(args)
+    return 0
+
+
+def cmd_workflow_init(args: argparse.Namespace) -> int:
+    print_rule("Pytron Workflow Generator")
+
+    project_root = Path(".").resolve()
+    github_dir = project_root / ".github" / "workflows"
+
+    if not github_dir.exists():
+        log(f"Creating directory: {github_dir}", style="dim")
+        github_dir.mkdir(parents=True, exist_ok=True)
+
+    workflow_file = github_dir / "package.yml"
+
+    if workflow_file.exists() and not getattr(args, "force", False):
+        log(f"Workflow file already exists at {workflow_file}", style="warning")
+        log("Use --force to overwrite.", style="dim")
+        return 1
+
+    log(f"Generating GitHub Action: {workflow_file}", style="info")
+    workflow_file.write_text(WORKFLOW_TEMPLATE, encoding="utf-8")
+
+    log("Successfully created multi-platform build workflow!", style="success")
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print(
+        "1. Commit the new file: [cyan]git add .github/workflows/package.yml[/cyan]"
+    )
+    console.print("2. Tag a version: [cyan]git tag v1.0.0[/cyan]")
+    console.print("3. Push to GitHub: [cyan]git push origin main --tags[/cyan]")
+    console.print(
+        "\nYour app will automatically build for Windows, Linux, and macOS on every tag push!"
+    )
+
+    return 0

pytron/console.py

@@ -0,0 +1,133 @@
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    BarColumn,
+    TimeElapsedColumn,
+)
+from rich.rule import Rule
+from rich.console import Console
+from rich.theme import Theme
+import subprocess
+import os
+import datetime
+
+# Export Rule so commands can use it directly
+__all__ = [
+    "console",
+    "log",
+    "get_progress",
+    "print_rule",
+    "run_command_with_output",
+    "Rule",
+    "set_log_file",
+]
+
+# Centralized Theme Definition
+# 'dim' is built-in but can be overridden if needed
+custom_theme = Theme(
+    {
+        "info": "cyan",
+        "warning": "yellow",
+        "error": "bold red",
+        "success": "bold green",
+        "dim": "dim white",
+    }
+)
+
+console = Console(theme=custom_theme)
+_log_file = None
+
+
+def set_log_file(path: str | None):
+    """Sets the file path for logging."""
+    global _log_file
+    if path:
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+    _log_file = path
+
+
+def log(
+    msg: str, style: str = "info", title: str = "Pytron", markup: bool = False
+) -> None:
+    """Helper to print [Pytron] messages with style and log to file."""
+    # Print to console
+    try:
+        # The title part is always markup (bold)
+        console.print(f"[bold][{title}][/bold] ", style=style, end="")
+        # The message part defaults to plain text for safety (e.g. paths with [])
+        console.print(msg, style=style, markup=markup)
+    except Exception:
+        # Fallback to plain print if the style or markup is invalid
+        print(f"[{title}] {msg}")
+
+    # Log to file if enabled
+    if _log_file:
+        try:
+            timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            with open(_log_file, "a", encoding="utf-8") as f:
+                f.write(f"[{timestamp}] [{title}] [{style.upper()}] {msg}\n")
+        except Exception:
+            pass  # Silently fail file logging if it fails
+
+
+def get_progress() -> Progress:
+    """Returns a configured Progress instance for consistent look.
+    Transient=True ensures the bar is removed from console after completion.
+    """
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        BarColumn(bar_width=None),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,
+    )
+
+
+def print_rule(title: str, style: str = "bold cyan") -> None:
+    console.print(Rule(f"[{style}]{title}"))
+
+
+def run_command_with_output(
+    cmd, env=None, cwd=None, style="dim", title=None, shell=False
+):
+    """Runs a command and streams output to the console, compatible with concurrent Progress display."""
+    try:
+        if title:
+            log(title, style="info")
+
+        # Use Popen to capture output
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # Merge stderr into stdout
+            text=True,
+            cwd=cwd,
+            env=env,
+            bufsize=1,  # Line buffered
+            shell=shell,
+        )  # nosec B602
+
+        for line in process.stdout:
+            # Strip only trailing newline to preserve some formatting (or strip both?)
+            # Usually output has \n at end, print() adds another.
+            stripped = line.rstrip()
+            if stripped:
+                # Printing to console while Progress is active automatically handles "moving" the output above the bar
+                console.print(stripped, style=style, markup=False)
+                # Also log to file if enabled (without rich tags)
+                if _log_file:
+                    try:
+                        with open(_log_file, "a", encoding="utf-8") as f:
+                            f.write(f"  {stripped}\n")
+                    except Exception:
+                        pass
+
+        process.wait()
+        return process.returncode
+    except Exception as e:
+        console.print("Error running command:", style="error", end=" ")
+        console.print(str(e), style="error", markup=False)
+        return 1

pytron/core.py

@@ -0,0 +1,18 @@
+# Re-export everything to maintain backward compatibility
+from .utils import get_resource_path
+from .serializer import PytronJSONEncoder, pytron_serialize
+from .state import ReactiveState
+from .application import App
+from .webview import Webview
+from .menu import Menu, MenuBar
+
+__all__ = [
+    "get_resource_path",
+    "PytronJSONEncoder",
+    "pytron_serialize",
+    "ReactiveState",
+    "App",
+    "Webview",
+    "Menu",
+    "MenuBar",
+]

pytron/dependencies/__init__.py

@@ -0,0 +1 @@
+# Pytron Native Dependencies