pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/commands/run.py

@@ -0,0 +1,312 @@
+import argparse
+import sys
+import shutil
+import subprocess
+import json
+import os
+from pathlib import Path
+from ..console import log, console
+from rich.text import Text
+from .helpers import (
+    locate_frontend_dir,
+    run_frontend_build,
+    get_python_executable,
+    ensure_next_config,
+    get_config,
+)
+
+try:
+    from watchfiles import DefaultFilter
+except ImportError:
+    DefaultFilter = object
+
+
+class PytronFilter(DefaultFilter):
+    def __init__(self, frontend_dir: Path = None, **kwargs):
+        self.frontend_dir = frontend_dir.resolve() if frontend_dir else None
+        self.ignore_dirs = {
+            ".git",
+            "__pycache__",
+            "node_modules",
+            "dist",
+            "build",
+            ".next",
+            ".output",
+            "coverage",
+            "env",
+            "venv",
+        }
+        super().__init__(**kwargs)
+
+    def __call__(self, change, path):
+        path_obj = Path(path).resolve()
+
+        # 1. Ignore common heavy or build directories
+        if any(part in self.ignore_dirs for part in path_obj.parts):
+            return False
+
+        # 2. Frontend specific ignores
+        if self.frontend_dir:
+            try:
+                if (
+                    self.frontend_dir in path_obj.parents
+                    or self.frontend_dir == path_obj
+                ):
+                    rel = path_obj.relative_to(self.frontend_dir)
+                    # Ignore source and assets to let HMR handle it
+                    if any(
+                        str(rel).startswith(p)
+                        for p in ["src", "public", "assets", "node_modules"]
+                    ):
+                        return False
+            except ValueError:
+                pass
+
+        # 3. Default filter (ignores binary files, etc.)
+        return super().__call__(change, path)
+
+
+def run_dev_mode(script: Path, extra_args: list[str], engine: str = None) -> int:
+    try:
+        from watchfiles import watch
+    except ImportError:
+        log(
+            "watchfiles is required for --dev mode. Install it with: pip install watchfiles",
+            style="error",
+        )
+        return 1
+
+    frontend_dir = locate_frontend_dir(Path("."))
+    watcher_filter = PytronFilter(frontend_dir=frontend_dir)
+
+    npm_proc = None
+    dev_server_url = None
+
+    if frontend_dir:
+        config = get_config()
+        provider = config.get("frontend_provider", "npm")
+        provider_bin = shutil.which(provider)
+
+        if provider_bin:
+            pkg_path = frontend_dir / "package.json"
+            pkg_data = json.loads(pkg_path.read_text())
+            scripts = pkg_data.get("scripts", {})
+
+            if "dev" in scripts:
+                log(
+                    f"Found 'dev' script. Starting development server using {provider}...",
+                    style="success",
+                )
+
+                # Setup Environment
+                proc_env = os.environ.copy()
+                dev_port = config.get("dev_port")
+                if dev_port:
+                    proc_env["PORT"] = str(dev_port)
+                    # Force color for nicer output
+                    proc_env["FORCE_COLOR"] = "1"
+
+                # We need to capture output to find the port, so PIPE it.
+                # But we also want the user to see it.
+                # We'll use a thread to read stdout and look for the URL.
+                npm_proc = subprocess.Popen(
+                    [provider_bin, "run", "dev"],
+                    cwd=str(frontend_dir),
+                    shell=False,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    env=proc_env,
+                    text=True,
+                    bufsize=1,
+                )  # nosec B603
+
+                # Scan for URL in a background thread
+                import threading
+                import re
+
+                url_found_event = threading.Event()
+
+                def scan_output():
+                    nonlocal dev_server_url
+                    # Regex for Local: http://localhost:PORT
+                    url_regex = re.compile(r"http://localhost:\d+")
+                    # Regex to strip ANSI codes (colors)
+                    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+                    while npm_proc and npm_proc.poll() is None:
+                        try:
+                            line = npm_proc.stdout.readline()
+                            if not line:
+                                break
+                            # Use Text.from_ansi to handle colors correctly
+                            prefix = Text(f"[{provider}] ", style="dim")
+                            content = Text.from_ansi(line.strip())
+                            console.print(prefix + content)
+
+                            if not dev_server_url:
+                                # Strip ANSI codes to ensure clean matching
+                                clean_line = ansi_escape.sub("", line)
+                                match = url_regex.search(clean_line)
+                                if match:
+                                    dev_server_url = match.group(0)
+                                    log(
+                                        f"Detected Dev Server URL: {dev_server_url}",
+                                        style="success",
+                                    )
+                                    url_found_event.set()
+                        except Exception as e:
+                            log(f"Error reading {provider} output: {e}", style="error")
+                            break
+
+                t = threading.Thread(target=scan_output, daemon=True)
+                t.start()
+
+                # Wait for a bit to find the URL
+                print(f"[Pytron] Waiting for {provider} dev server to start...")
+                url_found_event.wait(timeout=30)
+
+                if not dev_server_url:
+                    log(
+                        "Warning: Could not detect dev server URL. Python app might load old build.",
+                        style="warning",
+                    )
+
+            else:
+                # Fallback to old behavior (build --watch)
+                # Check for watch script
+                try:
+                    if "next" in pkg_data.get(
+                        "dependencies", {}
+                    ) or "next" in pkg_data.get("devDependencies", {}):
+                        ensure_next_config(frontend_dir)
+                except Exception:
+                    pass
+                args = ["run", "build"]
+
+                if "watch" in scripts:
+                    log("Found 'watch' script, using it.", style="success")
+                    args = ["run", "watch"]
+                else:
+                    # We'll try to append --watch to build if it's vite
+                    cmd_str = scripts.get("build", "")
+                    if "vite" in cmd_str and "--watch" not in cmd_str:
+                        log("Adding --watch to build command.")
+                        args = ["run", "build", "--", "--watch"]
+                    else:
+                        log(
+                            "No 'watch' script found, running build once.",
+                            style="warning",
+                        )
+
+                log(
+                    f"Starting frontend watcher: {provider} {' '.join(args)}",
+                    style="dim",
+                )
+                # Use shell=True for Windows compatibility
+                npm_proc = subprocess.Popen(
+                    [provider_bin] + args,
+                    cwd=str(frontend_dir),
+                    shell=False,
+                )  # nosec B603
+        else:
+            log(f"{provider} not found, skipping frontend watch.", style="warning")
+
+    app_proc = None
+
+    def kill_app():
+        nonlocal app_proc
+        if app_proc:
+            if sys.platform == "win32":
+                # Force kill process tree on Windows to ensure no lingering windows
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(app_proc.pid)],
+                    capture_output=True,
+                )
+            else:
+                app_proc.terminate()
+                try:
+                    app_proc.wait(timeout=1)
+                except subprocess.TimeoutExpired:
+                    app_proc.kill()
+            app_proc = None
+
+    def start_app():
+        nonlocal app_proc
+        kill_app()
+        log("Starting app...", style="info")
+        # Start as a subprocess we control
+        python_exe = get_python_executable()
+
+        env = os.environ.copy()
+        if dev_server_url:
+            env["PYTRON_DEV_URL"] = dev_server_url
+        if engine:
+            env["PYTRON_ENGINE"] = engine
+
+        app_proc = subprocess.Popen([python_exe, str(script)] + extra_args, env=env)
+
+    try:
+        start_app()
+        log(f"Watching for changes in {Path.cwd()}...", style="success")
+        for changes in watch(str(Path.cwd()), watch_filter=watcher_filter):
+            log(f"Detected changes: {changes}", style="dim")
+            # Filter out non-code changes manually if needed, but DevWatcher handles most
+            start_app()
+
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        log(f"Error in dev loop: {e}", style="error")
+    finally:
+        kill_app()
+        if npm_proc:
+            log("Stopping frontend watcher...", style="dim")
+            if sys.platform == "win32":
+                # Force kill the process tree to avoid "Terminate batch job (Y/N)?"
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(npm_proc.pid)],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+            else:
+                try:
+                    npm_proc.terminate()
+                    npm_proc.wait(timeout=2)
+                except Exception:
+                    npm_proc.kill()
+
+    return 0
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    script_path = args.script
+    if not script_path:
+        # Default to app.py in current directory
+        script_path = "app.py"
+
+    path = Path(script_path)
+    if not path.exists():
+        log(f"Script not found: {path}", style="error")
+        return 1
+
+    if not args.dev and not getattr(args, "no_build", False):
+        frontend_dir = locate_frontend_dir(path.parent)
+        if frontend_dir:
+            result = run_frontend_build(frontend_dir)
+            if result is False:
+                return 1
+
+    if args.dev:
+        engine = "chrome" if getattr(args, "chrome", False) else args.engine
+        return run_dev_mode(path, args.extra_args, engine=engine)
+
+    python_exe = get_python_executable()
+    env = os.environ.copy()
+    if getattr(args, "chrome", False):
+        env["PYTRON_ENGINE"] = "chrome"
+    elif args.engine:
+        env["PYTRON_ENGINE"] = args.engine
+
+    cmd = [python_exe, str(path)] + (args.extra_args or [])
+    log(f"Running: {' '.join(cmd)}", style="dim")
+    return subprocess.call(cmd, env=env)

pytron/commands/scan.py

@@ -0,0 +1,210 @@
+import argparse
+from pathlib import Path
+from ..console import console, log, Rule
+from ..pack.graph import GraphBuilder, DependencyOracle
+
+
+def cmd_scan(args: argparse.Namespace) -> int:
+    """
+    Runs the 'Oracle Scan' on a target project.
+    Visualizes insights without building.
+    """
+    target = args.target if args.target else "."
+    project_path = Path(target).resolve()
+
+    if not project_path.exists():
+        log(f"Path not found: {project_path}", style="error")
+        return 1
+
+    console.print(Rule("[bold magenta]Pytron Dependency Oracle"))
+    console.print(f"Scanning target: [cyan]{project_path}[/cyan]")
+
+    # 1. Build Graph
+    try:
+        builder = GraphBuilder(project_path)
+        graph = builder.scan_project()
+    except Exception as e:
+        log(f"Scan failed: {e}", style="error")
+        return 1
+
+    console.print(f"  Nodes: [bold]{len(graph.nodes)}[/bold]")
+    console.print(f"  Edges: [bold]{len(graph.edges)}[/bold]")
+    console.print(
+        f"  Uncertainty Zones: [bold red]{len(graph._uncertainty_zones)}[/bold red]"
+    )
+
+    # 2. Run Oracle
+    console.print(Rule("[bold yellow]Connecting to Brain..."))
+    oracle = DependencyOracle(graph)
+    oracle.predict()
+
+    # 3. Report Results
+    predictions = [e for e in graph.edges if e.type == "predicted"]
+
+    if predictions:
+        console.print(
+            f"Oracle made [bold green]{len(predictions)}[/bold green] inference(s):"
+        )
+        for pred in predictions:
+            confidence_style = "green" if pred.confidence > 0.8 else "yellow"
+            console.print(
+                f"  Ref: [cyan]{pred.source}[/cyan] -> [bold {confidence_style}]{pred.target}[/bold {confidence_style}]"
+            )
+            console.print(f"  Reason: [dim]{pred.reason}[/dim]")
+            console.print("")
+    else:
+        console.print(
+            "[dim]No dynamic anomalies detected. Standard build should suffice.[/dim]"
+        )
+
+    # 4. Show Uncertainty Zones (if unpredicted)
+    # Filter zones that didn't result in a prediction?
+    # For now, just show them all
+    if args.verbose and graph._uncertainty_zones:
+        console.print(Rule("[bold red]Uncertainty Zones"))
+        for zone in graph._uncertainty_zones:
+            console.print(f"[red]![/red] {zone['source']}:{zone['lineno']}")
+            console.print(f"    Code: `{zone['code']}`")
+            console.print(f"    Type: {zone['heuristic']}")
+            console.print("")
+
+    # 5. Export
+    if args.json:
+        out_file = project_path / "scan_report.json"
+        out_file.write_text(graph.to_json(), encoding="utf-8")
+        log(f"Report saved to {out_file}", style="success")
+
+    if getattr(args, "html", False):
+        html_path = project_path / "scan_graph.html"
+        generate_interactive_graph(graph, html_path)
+        log(f"Visual Graph saved to {html_path}", style="success")
+
+    return 0
+
+
+def generate_interactive_graph(graph, out_path: Path):
+    """Generates a standalone HTML D3.js graph."""
+    import json
+
+    data = json.loads(graph.to_json())
+
+    # Simple D3 Template
+    html = """
+<!DOCTYPE html>
+<html>
+<head>
+    <style> 
+        body { margin: 0; background: #111; color: #eee; font-family: sans-serif; overflow: hidden; } 
+        #graph { width: 100vw; height: 100vh; }
+        .node { stroke: #fff; stroke-width: 1.5px; }
+        .link { stroke: #555; stroke-opacity: 0.6; }
+        text { font-size: 10px; fill: #ccc; pointer-events: none; }
+        .tooltip { position: absolute; background: #333; padding: 5px; border: 1px solid #777; border-radius: 4px; display: none; }
+    </style>
+    <script src="https://d3js.org/d3.v7.min.js"></script>
+</head>
+<body>
+    <div id="graph"></div>
+    <div class="tooltip" id="tooltip"></div>
+    <script>
+        const data = __GRAPH_DATA__;
+        
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+        
+        // Convert map to array
+        const nodes = Object.values(data.nodes).map(n => ({id: n.name, type: n.type}));
+        const links = data.edges.map(e => ({source: e.source, target: e.target, type: e.type, conf: e.confidence}));
+        
+        const svg = d3.select("#graph").append("svg")
+            .attr("width", width)
+            .attr("height", height)
+            .call(d3.zoom().on("zoom", (event) => {
+                g.attr("transform", event.transform);
+            }));
+            
+        const g = svg.append("g");
+        
+        const simulation = d3.forceSimulation(nodes)
+            .force("link", d3.forceLink(links).id(d => d.id).distance(100))
+            .force("charge", d3.forceManyBody().strength(-300))
+            .force("center", d3.forceCenter(width / 2, height / 2));
+            
+        const link = g.append("g")
+            .attr("class", "links")
+            .selectAll("line")
+            .data(links)
+            .enter().append("line")
+            .attr("class", "link")
+            .attr("stroke", d => d.type === "predicted" ? "#0f0" : "#555")
+            .attr("stroke-dasharray", d => d.type === "predicted" ? "5,5" : "0")
+            .attr("stroke-width", d => Math.max(1, d.conf * 3));
+
+        const node = g.append("g")
+            .attr("class", "nodes")
+            .selectAll("circle")
+            .data(nodes)
+            .enter().append("circle")
+            .attr("r", 5)
+            .attr("fill", d => d.type === "package" ? "#f00" : "#00f")
+            .call(d3.drag()
+                .on("start", dragstarted)
+                .on("drag", dragged)
+                .on("end", dragended));
+
+        const label = g.append("g")
+            .selectAll("text")
+            .data(nodes)
+            .enter().append("text")
+            .attr("dy", -10)
+            .text(d => d.id);
+            
+        node.on("mouseover", (event, d) => {
+            d3.select("#tooltip")
+                .style("display", "block")
+                .style("left", (event.pageX + 10) + "px")
+                .style("top", (event.pageY - 10) + "px")
+                .html(`<strong>${d.id}</strong><br>${d.type}`);
+        }).on("mouseout", () => {
+            d3.select("#tooltip").style("display", "none");
+        });
+
+        simulation.on("tick", () => {
+            link
+                .attr("x1", d => d.source.x)
+                .attr("y1", d => d.source.y)
+                .attr("x2", d => d.target.x)
+                .attr("y2", d => d.target.y);
+
+            node
+                .attr("cx", d => d.x)
+                .attr("cy", d => d.y);
+                
+            label
+                .attr("x", d => d.x)
+                .attr("y", d => d.y);
+        });
+
+        function dragstarted(event, d) {
+            if (!event.active) simulation.alphaTarget(0.3).restart();
+            d.fx = d.x;
+            d.fy = d.y;
+        }
+
+        function dragged(event, d) {
+            d.fx = event.x;
+            d.fy = event.y;
+        }
+
+        function dragended(event, d) {
+            if (!event.active) simulation.alphaTarget(0);
+            d.fx = null;
+            d.fy = null;
+        }
+    </script>
+</body>
+</html>
+    """
+
+    html = html.replace("__GRAPH_DATA__", json.dumps(data))
+    out_path.write_text(html, encoding="utf-8")

pytron/commands/show.py

@@ -0,0 +1,23 @@
+import argparse
+from pathlib import Path
+from .helpers import get_venv_python_path
+from ..console import log, run_command_with_output
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    """
+    Shows list of installed packages in the virtual environment.
+    """
+    venv_dir = Path("env")
+    venv_python = get_venv_python_path(venv_dir)
+
+    if not venv_python.exists():
+        log(
+            f"Virtual environment not found at {venv_dir}. Run 'pytron install' first.",
+            style="error",
+        )
+        return 1
+
+    log(f"Installed packages in {venv_dir}:")
+    ret = run_command_with_output([str(venv_python), "-m", "pip", "list"])
+    return ret

pytron/commands/uninstall.py

@@ -0,0 +1,150 @@
+import re
+import subprocess
+import argparse
+import json
+from pathlib import Path
+from ..console import log, get_progress, run_command_with_output
+from .helpers import get_venv_python_path
+
+REQUIREMENTS_JSON = Path("requirements.json")
+
+
+def load_requirements():
+    if REQUIREMENTS_JSON.exists():
+        try:
+            return json.loads(REQUIREMENTS_JSON.read_text())
+        except Exception:
+            return {"dependencies": []}
+    return {"dependencies": []}
+
+
+def save_requirements(data):
+    REQUIREMENTS_JSON.write_text(json.dumps(data, indent=4))
+
+
+def get_installed_packages(venv_python) -> dict[str, str]:
+    """Returns a dict of {package_name: version} for all installed packages."""
+    try:
+        cmd = [str(venv_python), "-m", "pip", "list", "--format=json"]
+        output = subprocess.check_output(
+            cmd, text=True, stderr=subprocess.DEVNULL
+        ).strip()
+        data = json.loads(output)
+        return {item["name"].lower(): item["version"] for item in data}
+    except Exception:
+        return {}
+
+
+def get_package_name_from_source(path: Path) -> str | None:
+    """Attempts to read package name from pyproject.toml."""
+    try:
+        pyproject = path / "pyproject.toml"
+        if pyproject.exists():
+            content = pyproject.read_text(encoding="utf-8")
+            match = re.search(r'(?m)^name\s*=\s*["\']([^"\']+)["\']', content)
+            if match:
+                return match.group(1).lower()
+    except Exception:
+        pass
+    return None
+
+
+def cmd_uninstall(args: argparse.Namespace) -> int:
+    """
+    Uninstalls dependencies from the project environment and updates requirements.json.
+    """
+    packages_to_uninstall = args.packages
+    if not packages_to_uninstall:
+        log("No packages specified to uninstall.", style="warning")
+        return 0
+
+    venv_dir = Path("env")
+    venv_python = get_venv_python_path(venv_dir)
+
+    # Resolve names for requirements.json removal
+    resolved_names = []
+    for pkg in packages_to_uninstall:
+        name = pkg.lower()
+        if Path(pkg).exists():
+            source_name = get_package_name_from_source(Path(pkg))
+            if source_name:
+                name = source_name
+            else:
+                # Last ditch: check if it's the current pytron-kit folder itself
+                name = Path(pkg).name.lower()
+        resolved_names.append(name)
+
+    if not venv_python.exists():
+        log(
+            f"Virtual environment not found at {venv_dir}. Only updating {REQUIREMENTS_JSON}.",
+            style="warning",
+        )
+    else:
+        log(f"Uninstalling: {', '.join(packages_to_uninstall)}")
+
+        progress = get_progress()
+        progress.start()
+        progress.add_task("Uninstalling...", total=None)
+
+        # -y for non-interactive uninstall
+        # We pass original args to pip because pip handles paths if it knows the package name is installed from it
+        # but usually it prefers the name.
+        pip_args = []
+        for pkg in packages_to_uninstall:
+            if Path(pkg).exists():
+                # If user passed a path, we try to use the resolved name for pip uninstall
+                # because pip uninstall <path> usually doesn't work (it wants the DIST name)
+                name = get_package_name_from_source(Path(pkg)) or Path(pkg).name.lower()
+                pip_args.append(name)
+            else:
+                pip_args.append(pkg)
+
+        cmd = [str(venv_python), "-m", "pip", "uninstall", "-y"] + pip_args
+        ret = run_command_with_output(cmd, style="dim")
+
+        progress.stop()
+
+        if ret == 0:
+            log("Packages uninstalled from environment successfully.", style="success")
+        else:
+            log("Some packages failed to uninstall or were not found.", style="warning")
+
+    # Update requirements.json
+    req_data = load_requirements()
+    current_deps = req_data.get("dependencies", [])
+
+    updated_deps = []
+    removed_count = 0
+
+    for dep in current_deps:
+        base_name = (
+            dep.split("==")[0]
+            .split(">=")[0]
+            .split("<=")[0]
+            .split("<")[0]
+            .split(">")[0]
+            .strip()
+            .lower()
+        )
+
+        should_remove = False
+        for name in resolved_names:
+            if name == base_name:
+                should_remove = True
+                break
+
+        if should_remove:
+            removed_count += 1
+        else:
+            updated_deps.append(dep)
+
+    if removed_count > 0:
+        req_data["dependencies"] = updated_deps
+        save_requirements(req_data)
+        log(f"Removed {removed_count} packages from {REQUIREMENTS_JSON}", style="info")
+    else:
+        log(f"No changes made to {REQUIREMENTS_JSON}", style="dim")
+
+    return 0
+
+    return 0