PyPI - pdit - Versions diffs - 0.1.0__py3-none-any.whl - Mend

pdit 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

pdit/__init__.py +11 -0
pdit/_static/assets/index-BkEyY6gm.js +135 -0
pdit/_static/assets/index-DxOOJTA1.css +1 -0
pdit/_static/export.html +74 -0
pdit/_static/index.html +14 -0
pdit/cli.py +250 -0
pdit/exporter.py +90 -0
pdit/file_watcher.py +162 -0
pdit/ipython_executor.py +350 -0
pdit/server.py +410 -0
pdit-0.1.0.dist-info/METADATA +155 -0
pdit-0.1.0.dist-info/RECORD +15 -0
pdit-0.1.0.dist-info/WHEEL +5 -0
pdit-0.1.0.dist-info/entry_points.txt +2 -0
pdit-0.1.0.dist-info/top_level.txt +1 -0

pdit/_static/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>pdit</title>
+    <script type="module" crossorigin src="/assets/index-BkEyY6gm.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DxOOJTA1.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

pdit/cli.py ADDED Viewed

@@ -0,0 +1,250 @@
+"""
+Command-line interface for pdit.
+Provides the `pdit` command to start the server and open the web interface.
+"""
+import contextlib
+import signal
+import socket
+import sys
+import time
+import threading
+import webbrowser
+import secrets
+import urllib.parse
+from pathlib import Path
+from typing import Optional
+import typer
+from typing_extensions import Annotated
+import uvicorn
+# Flag for graceful shutdown on SIGTERM
+_shutdown_requested = False
+app = typer.Typer(add_completion=False)
+def find_available_port(start_port=8888, max_tries=100):
+    """Find an available port starting from start_port.
+    Args:
+        start_port: Port to start searching from
+        max_tries: Maximum number of ports to try
+    Returns:
+        Available port number
+    Raises:
+        RuntimeError: If no available port found within max_tries
+    """
+    for port in range(start_port, start_port + max_tries):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                # Allow reuse of ports in TIME_WAIT state
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind(("127.0.0.1", port))
+                return port
+        except OSError:
+            continue
+    raise RuntimeError(f"Could not find available port in range {start_port}-{start_port + max_tries}")
+class Server(uvicorn.Server):
+    """Custom Server class that can run in a background thread."""
+    def install_signal_handlers(self):
+        """Disable signal handlers for threading compatibility."""
+        pass
+    @contextlib.contextmanager
+    def run_in_thread(self):
+        """Run server in background thread, wait for startup."""
+        thread = threading.Thread(target=self.run, daemon=True)
+        thread.start()
+        try:
+            # Wait for server to be ready
+            while not self.started:
+                time.sleep(1e-3)
+            yield
+        finally:
+            # Signal WebSocket connections to close before shutting down server
+            from .server import signal_shutdown
+            signal_shutdown()
+            # Give connections a moment to close
+            time.sleep(0.2)
+            # Clean shutdown
+            self.should_exit = True
+            thread.join(timeout=3.0)
+            if thread.is_alive():
+                # Force exit if shutdown takes too long
+                import sys
+                sys.exit(1)
+def start(
+    script: Optional[Path] = None,
+    port: Optional[int] = None,
+    host: str = "127.0.0.1",
+    no_browser: bool = False,
+    no_token_auth: bool = False,
+):
+    """Start the pdit server with optional script."""
+    # Check if frontend is built
+    static_dir = Path(__file__).parent / "_static"
+    if not static_dir.exists() or not (static_dir / "index.html").exists():
+        typer.echo("Warning: Frontend build not found at pdit/_static/", err=True)
+        typer.echo("The server will start but the web interface won't be available.", err=True)
+        typer.echo("Run './scripts/build-frontend.sh' to build and copy the frontend.", err=True)
+        typer.echo()
+    # Use script path as-is (relative to current directory)
+    script_path = None
+    if script:
+        script_path = str(script)
+    # Determine port to use
+    if port is None:
+        # No port specified: find available port starting from 8888
+        actual_port = find_available_port(start_port=8888)
+        if actual_port != 8888:
+            typer.echo(f"Port 8888 is already in use, using port {actual_port} instead")
+    else:
+        # Port explicitly specified: use it or fail
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                # Allow reuse of ports in TIME_WAIT state
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind((host, port))
+                actual_port = port
+        except OSError:
+            typer.echo(f"Error: Port {port} is already in use", err=True)
+            sys.exit(1)
+    # Pass port/token to server via environment variables for CORS and auth
+    import os
+    os.environ["PDIT_PORT"] = str(actual_port)
+    token = None
+    if no_token_auth:
+        os.environ.pop("PDIT_TOKEN", None)
+    else:
+        token = os.environ.get("PDIT_TOKEN")
+        if not token:
+            token = secrets.token_urlsafe(24)
+            os.environ["PDIT_TOKEN"] = token
+    # Build URL with token and optional script
+    url = f"http://{host}:{actual_port}"
+    params = {}
+    if script_path:
+        params["script"] = script_path
+    if token:
+        params["token"] = token
+    if params:
+        url = f"{url}?{urllib.parse.urlencode(params)}"
+    typer.echo(f"Starting pdit server on {host}:{actual_port}")
+    # Configure and create server
+    config = uvicorn.Config(
+        "pdit.server:app",
+        host=host,
+        port=actual_port,
+        log_level="info"
+    )
+    server = Server(config=config)
+    # Run server in thread, open browser when ready
+    with server.run_in_thread():
+        # Server is guaranteed to be ready here
+        if not no_browser:
+            webbrowser.open(url)
+            typer.echo(f"Opening browser to {url}")
+        # Set up SIGTERM handler for graceful shutdown
+        def handle_sigterm(signum, frame):
+            global _shutdown_requested
+            _shutdown_requested = True
+        signal.signal(signal.SIGTERM, handle_sigterm)
+        # Keep server running
+        try:
+            while not _shutdown_requested:
+                time.sleep(0.1)  # Check more frequently for shutdown
+            typer.echo("\nShutting down...")
+        except KeyboardInterrupt:
+            typer.echo("\nShutting down...")
+@app.command()
+def main_command(
+    script: Annotated[
+        Optional[Path],
+        typer.Argument(help="Python script file to open", exists=True, dir_okay=False)
+    ] = None,
+    export: Annotated[
+        bool,
+        typer.Option("--export", "-e", help="Export script to self-contained HTML file")
+    ] = False,
+    output: Annotated[
+        Optional[Path],
+        typer.Option("-o", "--output", help="Output file for export (default: script.html)")
+    ] = None,
+    stdout: Annotated[
+        bool,
+        typer.Option("--stdout", help="Write export to stdout instead of file")
+    ] = False,
+    port: Annotated[
+        Optional[int],
+        typer.Option(help="Port to run server on (default: 8888, or next available)")
+    ] = None,
+    host: Annotated[
+        str,
+        typer.Option(help="Host to bind to")
+    ] = "127.0.0.1",
+    no_browser: Annotated[
+        bool,
+        typer.Option("--no-browser", help="Don't open browser automatically")
+    ] = False,
+    no_token_auth: Annotated[
+        bool,
+        typer.Option("--no-token-auth", help="Disable token authentication for API access")
+    ] = False,
+):
+    """Start the pdit server, or export a script to HTML with --export."""
+    if export:
+        if not script:
+            typer.echo("Error: script is required for --export", err=True)
+            raise typer.Exit(1)
+        from .exporter import export_script
+        try:
+            html_output = export_script(script)
+        except FileNotFoundError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1)
+        if stdout:
+            typer.echo(html_output)
+        else:
+            output_path = output if output else script.with_suffix('.html')
+            output_path.write_text(html_output)
+            typer.echo(f"Exported to {output_path}")
+    else:
+        start(script, port, host, no_browser, no_token_auth)
+def main():
+    """Entry point for the CLI."""
+    app()
+if __name__ == "__main__":
+    app()

pdit/exporter.py ADDED Viewed

@@ -0,0 +1,90 @@
+"""Export functionality for pdit scripts."""
+import json
+from pathlib import Path
+from typing import Any
+from .ipython_executor import IPythonExecutor
+def execute_script(script_content: str, script_name: str) -> list[dict[str, Any]]:
+    """Execute a script and return expressions in frontend format.
+    Args:
+        script_content: The Python source code to execute
+        script_name: Name of the script (for error messages)
+    Returns:
+        List of expression dicts ready for frontend consumption
+    """
+    executor = IPythonExecutor()
+    expressions = []
+    expression_id = 0
+    try:
+        for event in executor.execute_script(script_content, script_name=script_name):
+            # Skip the expressions list event
+            if event.get("type") == "expressions":
+                continue
+            # Result events have output field
+            if "output" in event:
+                expressions.append({
+                    "id": expression_id,
+                    "lineStart": event["lineStart"],
+                    "lineEnd": event["lineEnd"],
+                    "state": "done",
+                    "result": {
+                        "output": event["output"],
+                        "isInvisible": event["isInvisible"]
+                    }
+                })
+                expression_id += 1
+    finally:
+        executor.shutdown()
+    return expressions
+def generate_html(script_content: str, expressions: list[dict[str, Any]]) -> str:
+    """Generate self-contained HTML from script and execution results.
+    Args:
+        script_content: The original Python source code
+        expressions: List of expression results from execute_script()
+    Returns:
+        Complete HTML string ready to write to file
+    Raises:
+        FileNotFoundError: If export.html template is missing
+    """
+    static_dir = Path(__file__).parent / "_static"
+    export_html_path = static_dir / "export.html"
+    if not export_html_path.exists():
+        raise FileNotFoundError("export.html not found. Run './scripts/build-frontend.sh' first.")
+    template = export_html_path.read_text()
+    response_data = {
+        "code": script_content,
+        "expressions": expressions
+    }
+    json_data = json.dumps(response_data).replace("<", "\\u003c")
+    injection_script = f'<script>window.__pdit_response__ = {json_data};</script>'
+    return template.replace('</head>', f'{injection_script}\n</head>')
+def export_script(script_path: Path) -> str:
+    """Execute a script and generate HTML export.
+    Args:
+        script_path: Path to the Python script
+    Returns:
+        Complete HTML string
+    """
+    script_content = script_path.read_text()
+    expressions = execute_script(script_content, script_path.name)
+    return generate_html(script_content, expressions)

pdit/file_watcher.py ADDED Viewed

@@ -0,0 +1,162 @@
+"""
+File watching functionality using watchfiles.
+Provides a FileWatcher class that monitors a single file for changes
+and streams events through an async queue.
+"""
+import threading
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import AsyncGenerator, Optional, Union
+from watchfiles import awatch
+import time
+@dataclass
+class FileEvent:
+    """Base class for file watcher events."""
+    path: str
+    timestamp: int
+    type: str = field(init=False)
+@dataclass
+class InitialFileEvent(FileEvent):
+    """Initial file content event."""
+    content: str
+    type: str = field(default="initial", init=False)
+@dataclass
+class FileChangedEvent(FileEvent):
+    """File modification event."""
+    content: str
+    type: str = field(default="fileChanged", init=False)
+@dataclass
+class FileDeletedEvent(FileEvent):
+    """File deletion event."""
+    type: str = field(default="fileDeleted", init=False)
+@dataclass
+class FileErrorEvent(FileEvent):
+    """File error event."""
+    message: str
+    type: str = field(default="error", init=False)
+class FileWatcher:
+    """Watch a single file for changes and stream events.
+    Uses watchfiles (Rust-based) for fast, async file watching.
+    Usage:
+        watcher = FileWatcher("/path/to/file.py")
+        async for event in watcher.watch_with_initial():
+            if isinstance(event, InitialFileEvent):
+                print(f"Initial: {event.content}")
+            elif isinstance(event, FileChangedEvent):
+                print(f"Changed: {event.content}")
+            elif isinstance(event, FileDeletedEvent):
+                print("Deleted")
+    """
+    def __init__(self, file_path: str, stop_event: Optional[threading.Event] = None):
+        """Initialize file watcher.
+        Args:
+            file_path: Absolute path to file to watch
+            stop_event: Optional threading.Event to signal watcher to stop
+        """
+        self.file_path = Path(file_path).resolve()
+        self.stop_event = stop_event
+    async def watch_with_initial(
+        self
+    ) -> AsyncGenerator[Union[InitialFileEvent, FileChangedEvent, FileDeletedEvent, FileErrorEvent], None]:
+        """Watch file with initial content event.
+        Encapsulates all domain logic: file validation, reading, timestamps, error handling.
+        Yields:
+            FileEvent subclasses with all domain data
+        Example:
+            watcher = FileWatcher("/path/to/file.py")
+            async for event in watcher.watch_with_initial():
+                if isinstance(event, InitialFileEvent):
+                    print(f"Initial: {event.content}")
+                elif isinstance(event, FileChangedEvent):
+                    print(f"Changed: {event.content}")
+        """
+        # Validate file exists
+        if not self.file_path.exists():
+            yield FileErrorEvent(
+                path=str(self.file_path),
+                message=f"File not found: {self.file_path}",
+                timestamp=int(time.time())
+            )
+            return
+        # Read and yield initial content
+        try:
+            content = self.file_path.read_text()
+            timestamp = int(time.time())
+            yield InitialFileEvent(
+                path=str(self.file_path),
+                content=content,
+                timestamp=timestamp
+            )
+        except Exception as e:
+            yield FileErrorEvent(
+                path=str(self.file_path),
+                message=f"Error reading file: {str(e)}",
+                timestamp=int(time.time())
+            )
+            return
+        # Watch for changes in parent directory to detect deletion
+        watch_path = self.file_path.parent
+        # Use rust_timeout to make awatch check stop_event frequently (100ms)
+        # This ensures quick response to server shutdown
+        async for changes in awatch(watch_path, stop_event=self.stop_event, rust_timeout=100):
+            for change_type, changed_path in changes:
+                changed_path = Path(changed_path).resolve()
+                # Skip events for other files
+                if changed_path != self.file_path:
+                    continue
+                from watchfiles import Change
+                # Handle file deletion
+                if change_type == Change.deleted:
+                    yield FileDeletedEvent(
+                        path=str(self.file_path),
+                        timestamp=int(time.time())
+                    )
+                    return
+                # Handle file modification (Change.added or Change.modified)
+                try:
+                    content = self.file_path.read_text()
+                    timestamp = int(time.time())
+                    yield FileChangedEvent(
+                        path=str(self.file_path),
+                        content=content,
+                        timestamp=timestamp
+                    )
+                except Exception as e:
+                    yield FileErrorEvent(
+                        path=str(self.file_path),
+                        message=f"Error reading file: {str(e)}",
+                        timestamp=int(time.time())
+                    )
+                    return