quantum-framework 0.18.0__py3-none-any.whl

quantum/cli/commands/serve.py

@@ -0,0 +1,190 @@
+"""
+Quantum CLI - Serve Command
+
+Serve built files with a static file server.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+import mimetypes
+
+import click
+
+from quantum.cli.utils import get_console, find_project_root
+
+
+@click.command('serve')
+@click.option('--port', '-p', type=int, default=8080, help='Port to serve on')
+@click.option('--host', '-h', type=str, default='0.0.0.0', help='Host to bind to')
+@click.option('--directory', '-d', type=click.Path(exists=True), default='./dist',
+              help='Directory to serve')
+@click.option('--cors', is_flag=True, help='Enable CORS headers')
+@click.option('--spa', is_flag=True, help='SPA mode - serve index.html for all routes')
+@click.option('--quiet', '-q', is_flag=True, help='Quiet mode')
+def serve(port: int, host: str, directory: str, cors: bool, spa: bool, quiet: bool):
+    """Serve built files with a static file server.
+
+    Serves the contents of the dist directory (or specified directory).
+
+    Examples:
+
+        quantum serve
+
+        quantum serve --port 3000
+
+        quantum serve --directory ./build --cors
+
+        quantum serve --spa  # For single-page applications
+    """
+    console = get_console(quiet=quiet)
+
+    # Resolve directory path
+    serve_dir = Path(directory)
+    if not serve_dir.is_absolute():
+        project_root = find_project_root() or Path.cwd()
+        serve_dir = project_root / directory
+
+    if not serve_dir.exists():
+        console.error(f"Directory not found: {serve_dir}")
+        console.info("Run 'quantum build' first to create build output")
+        raise click.Abort()
+
+    # Check for index.html
+    index_file = serve_dir / 'index.html'
+    if not index_file.exists():
+        # Look for any .html file
+        html_files = list(serve_dir.glob('*.html'))
+        if html_files:
+            console.warning(f"No index.html found, but found: {', '.join(f.name for f in html_files[:3])}")
+        else:
+            console.warning("No HTML files found in directory")
+
+    url = f"http://{host if host != '0.0.0.0' else 'localhost'}:{port}"
+
+    console.header(
+        "Quantum Static Server",
+        f"Serving: {serve_dir}"
+    )
+
+    console.panel(
+        f"[bold]URL:[/bold] {url}\n"
+        f"[bold]Directory:[/bold] {serve_dir}\n"
+        f"[bold]CORS:[/bold] {'Enabled' if cors else 'Disabled'}\n"
+        f"[bold]SPA Mode:[/bold] {'Enabled' if spa else 'Disabled'}",
+        title="Server Configuration",
+        style="green"
+    )
+
+    console.print()
+    console.info(f"Server running at {url}")
+    console.print("[dim]Press Ctrl+C to stop[/dim]")
+    console.print()
+
+    # Start server
+    try:
+        _run_server(serve_dir, host, port, cors, spa, console)
+    except KeyboardInterrupt:
+        console.print()
+        console.info("Server stopped")
+    except Exception as e:
+        console.error(f"Server error: {e}")
+        raise click.Abort()
+
+
+def _run_server(
+    directory: Path,
+    host: str,
+    port: int,
+    cors: bool,
+    spa: bool,
+    console
+):
+    """Run the static file server."""
+    from http.server import HTTPServer, SimpleHTTPRequestHandler
+    import urllib.parse
+
+    class QuantumHandler(SimpleHTTPRequestHandler):
+        """Custom handler with CORS and SPA support."""
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, directory=str(directory), **kwargs)
+
+        def log_message(self, format, *args):
+            """Log requests to console."""
+            message = format % args
+            # Parse status code
+            parts = message.split('"')
+            if len(parts) >= 3:
+                status = parts[2].strip().split()[0]
+                method_path = parts[1]
+                if status.startswith('2'):
+                    console.print(f"[green]{status}[/green] {method_path}")
+                elif status.startswith('3'):
+                    console.print(f"[yellow]{status}[/yellow] {method_path}")
+                elif status.startswith('4') or status.startswith('5'):
+                    console.print(f"[red]{status}[/red] {method_path}")
+                else:
+                    console.print(f"{status} {method_path}")
+            else:
+                console.print(message)
+
+        def end_headers(self):
+            """Add CORS headers if enabled."""
+            if cors:
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+                self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+            super().end_headers()
+
+        def do_OPTIONS(self):
+            """Handle CORS preflight requests."""
+            if cors:
+                self.send_response(200)
+                self.end_headers()
+            else:
+                self.send_error(405, "Method Not Allowed")
+
+        def do_GET(self):
+            """Handle GET requests with SPA support."""
+            if spa:
+                # Parse the URL path
+                parsed = urllib.parse.urlparse(self.path)
+                path = parsed.path
+
+                # Check if file exists
+                file_path = directory / path.lstrip('/')
+
+                if not file_path.exists() and not path.startswith('/assets'):
+                    # Check if it's a file request (has extension)
+                    if '.' not in Path(path).name:
+                        # Serve index.html for SPA routes
+                        self.path = '/index.html'
+
+            super().do_GET()
+
+        def guess_type(self, path):
+            """Guess content type with better defaults."""
+            content_type, _ = mimetypes.guess_type(path)
+            if content_type:
+                return content_type
+
+            # Additional mappings
+            ext = Path(path).suffix.lower()
+            type_map = {
+                '.q': 'text/xml',
+                '.yaml': 'text/yaml',
+                '.yml': 'text/yaml',
+                '.wasm': 'application/wasm',
+                '.mjs': 'application/javascript',
+            }
+            return type_map.get(ext, 'application/octet-stream')
+
+    # Create and start server
+    server = HTTPServer((host, port), QuantumHandler)
+
+    try:
+        server.serve_forever()
+    finally:
+        server.server_close()

quantum/cli/commands/test.py

@@ -0,0 +1,193 @@
+"""
+Quantum CLI - Test Command
+
+Run tests for Quantum applications.
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+from typing import Optional, List
+
+import click
+
+from quantum.cli.utils import get_console, find_project_root
+
+
+@click.command('test')
+@click.argument('path', required=False, type=click.Path())
+@click.option('--pattern', '-p', type=str, default='test_*.py',
+              help='Test file pattern')
+@click.option('--coverage', '-c', is_flag=True, help='Run with coverage')
+@click.option('--verbose', '-v', is_flag=True, help='Verbose output')
+@click.option('--watch', '-w', is_flag=True, help='Watch mode - rerun on changes')
+@click.option('--filter', '-k', type=str, help='Filter tests by name pattern')
+@click.option('--markers', '-m', type=str, help='Run tests with specific markers')
+@click.option('--fail-fast', '-x', is_flag=True, help='Stop on first failure')
+@click.option('--quiet', '-q', is_flag=True, help='Quiet mode')
+def test(
+    path: Optional[str],
+    pattern: str,
+    coverage: bool,
+    verbose: bool,
+    watch: bool,
+    filter: Optional[str],
+    markers: Optional[str],
+    fail_fast: bool,
+    quiet: bool
+):
+    """Run tests for Quantum applications.
+
+    Uses pytest to run tests from the tests/ directory.
+
+    Examples:
+
+        quantum test
+
+        quantum test tests/unit/
+
+        quantum test --coverage
+
+        quantum test -k "test_parser" -v
+
+        quantum test --watch
+    """
+    console = get_console(quiet=quiet)
+
+    # Find project root
+    project_root = find_project_root()
+    if not project_root:
+        console.error("No Quantum project found")
+        raise click.Abort()
+
+    # Determine test path
+    if path:
+        test_path = Path(path)
+        if not test_path.is_absolute():
+            test_path = project_root / path
+    else:
+        test_path = project_root / 'tests'
+
+    if not test_path.exists():
+        console.error(f"Test path not found: {test_path}")
+        console.info("Create a 'tests/' directory with test files")
+        raise click.Abort()
+
+    console.header(
+        "Running Quantum Tests",
+        f"Path: {test_path}"
+    )
+
+    # Check for pytest
+    try:
+        subprocess.run(['pytest', '--version'], capture_output=True, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        console.error("pytest not found. Install with: pip install pytest")
+        raise click.Abort()
+
+    # Build pytest command
+    cmd = ['pytest', str(test_path)]
+
+    if verbose:
+        cmd.append('-v')
+
+    if fail_fast:
+        cmd.append('-x')
+
+    if filter:
+        cmd.extend(['-k', filter])
+
+    if markers:
+        cmd.extend(['-m', markers])
+
+    if coverage:
+        # Check for pytest-cov
+        try:
+            import pytest_cov
+        except ImportError:
+            console.warning("pytest-cov not found. Install with: pip install pytest-cov")
+            console.info("Running without coverage...")
+        else:
+            cmd.extend(['--cov=src', '--cov-report=term-missing', '--cov-report=html'])
+
+    # Add src to PYTHONPATH
+    env = os.environ.copy()
+    src_path = str(project_root / 'src')
+    env['PYTHONPATH'] = src_path + os.pathsep + env.get('PYTHONPATH', '')
+
+    console.info(f"Running: {' '.join(cmd)}")
+    console.print()
+
+    if watch:
+        _watch_and_test(project_root, cmd, env, console)
+    else:
+        # Run tests
+        result = subprocess.run(cmd, cwd=project_root, env=env)
+
+        if result.returncode == 0:
+            console.print()
+            console.success("All tests passed!")
+        else:
+            console.print()
+            console.error(f"Tests failed with exit code {result.returncode}")
+            sys.exit(result.returncode)
+
+
+def _watch_and_test(project_root: Path, cmd: List[str], env: dict, console):
+    """Watch for changes and rerun tests."""
+    import time
+    import signal
+
+    last_mtimes = {}
+
+    def get_file_mtimes():
+        mtimes = {}
+        for ext in ['.py', '.q']:
+            for f in project_root.rglob(f'*{ext}'):
+                # Skip __pycache__
+                if '__pycache__' in str(f):
+                    continue
+                try:
+                    mtimes[f] = f.stat().st_mtime
+                except OSError:
+                    pass
+        return mtimes
+
+    def run_tests():
+        console.print()
+        console.info("Running tests...")
+        console.print()
+        subprocess.run(cmd, cwd=project_root, env=env)
+
+    def signal_handler(sig, frame):
+        console.print()
+        console.info("Stopping watch mode...")
+        raise SystemExit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Initial run
+    run_tests()
+    last_mtimes = get_file_mtimes()
+
+    console.print()
+    console.info("Watching for changes... (Ctrl+C to stop)")
+
+    while True:
+        time.sleep(1)
+        current_mtimes = get_file_mtimes()
+
+        changed = []
+        for f, mtime in current_mtimes.items():
+            if f not in last_mtimes or mtime > last_mtimes[f]:
+                changed.append(f)
+
+        if changed:
+            console.print()
+            for f in changed:
+                rel_path = f.relative_to(project_root)
+                console.info(f"Changed: {rel_path}")
+
+            run_tests()
+            last_mtimes = current_mtimes