quantum-framework 0.9.0__py3-none-any.whl

quantum/cli/server_process.py

@@ -0,0 +1,159 @@
+"""
+Parar o servidor iniciado por `quantum start` e CONFERIR que ele parou.
+
+O `quantum stop` antigo matava o PID do `.quantum.pid`, imprimia "Server
+stopped" e saia com 0 — sem olhar se alguma coisa tinha parado. Com
+`reload: true` (o padrao do quantum.config.yaml) o Werkzeug serve a partir de
+um processo FILHO; o arquivo tinha so o PID do pai. No Windows,
+`taskkill /F` sem `/T` derruba so o pai, e o filho seguia vivo, orfao,
+respondendo HTTP 200 na mesma porta.
+
+Agora:
+- o `.quantum.pid` guarda o pai e, quando ha reloader, o filho (uma linha
+  cada — o formato antigo, uma linha so, continua valido);
+- o stop derruba a arvore de cada PID, espera, e so declara sucesso se
+  nenhum deles continuar vivo. Se sobrar algum, diz qual e sai com 1.
+"""
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+from typing import Callable, List
+
+PID_FILE = '.quantum.pid'
+
+
+def read_pids(pid_file: Path) -> List[int]:
+    """PIDs listados no arquivo, na ordem, sem repetir.
+
+    Levanta ValueError se o arquivo nao tiver nenhum inteiro valido.
+    """
+    pids: List[int] = []
+    for linha in pid_file.read_text(encoding='utf-8').split():
+        pid = int(linha)
+        if pid not in pids:
+            pids.append(pid)
+    if not pids:
+        raise ValueError(f"{pid_file} is empty")
+    return pids
+
+
+def pid_alive(pid: int) -> bool:
+    """O processo existe e ainda nao terminou?"""
+    if pid <= 0:
+        return False
+    if os.name == 'nt':
+        return _pid_alive_windows(pid)
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        pass  # existe, so nao e nosso
+    return not _exited_unreaped(pid)
+
+
+def _exited_unreaped(pid: int) -> bool:
+    """O PID ainda existe na tabela, mas o processo ja terminou?"""
+    # Um processo que terminou e ainda nao foi recolhido pelo pai (zumbi)
+    # responde a os.kill(pid, 0) como se estivesse vivo. Nao esta: nao roda,
+    # nao segura porta. Sem isso, parar um servidor cujo pai demora a chamar
+    # wait() — um supervisor, ou o proprio pytest — dava "still running".
+    try:
+        with open(f'/proc/{pid}/stat', 'rb') as f:
+            estado = f.read().rsplit(b')', 1)[1].split()[0]
+    except FileNotFoundError:
+        return os.path.isdir('/proc')  # /proc existe e o pid nao: ja foi embora
+    except (OSError, IndexError):
+        return False  # sem /proc (macOS): fica com o resultado do os.kill
+    return estado in (b'Z', b'X')
+
+
+def _pid_alive_windows(pid: int) -> bool:
+    # os.kill(pid, 0) NAO serve no Windows: qualquer sinal que nao seja
+    # CTRL_C/CTRL_BREAK vira TerminateProcess — a checagem mataria o processo.
+    import ctypes
+    from ctypes import wintypes
+
+    PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+    STILL_ACTIVE = 259
+    ERROR_ACCESS_DENIED = 5
+
+    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+    kernel32.OpenProcess.restype = wintypes.HANDLE
+    handle = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+    if not handle:
+        return ctypes.get_last_error() == ERROR_ACCESS_DENIED
+    try:
+        codigo = wintypes.DWORD()
+        if not kernel32.GetExitCodeProcess(handle, ctypes.byref(codigo)):
+            return False
+        return codigo.value == STILL_ACTIVE
+    finally:
+        kernel32.CloseHandle(handle)
+
+
+def _terminate(pid: int, force: bool) -> None:
+    if os.name == 'nt':
+        # /T derruba a arvore inteira: o filho do reloader junto com o pai.
+        subprocess.run(['taskkill', '/F', '/T', '/PID', str(pid)],
+                       capture_output=True)
+        return
+    try:
+        os.kill(pid, signal.SIGKILL if force else signal.SIGTERM)
+    except (ProcessLookupError, PermissionError):
+        pass
+
+
+def _wait_until_dead(pids: List[int], timeout: float,
+                     alive: Callable[[int], bool]) -> List[int]:
+    limite = time.monotonic() + timeout
+    vivos = [p for p in pids if alive(p)]
+    while vivos and time.monotonic() < limite:
+        time.sleep(0.2)
+        vivos = [p for p in vivos if alive(p)]
+    return vivos
+
+
+def stop_server(pid_file: Path = Path(PID_FILE), grace: float = 5.0,
+                alive: Callable[[int], bool] = pid_alive,
+                terminate: Callable[[int, bool], None] = _terminate) -> int:
+    """Para o servidor do `pid_file`. Devolve o codigo de saida do comando."""
+    if not pid_file.exists():
+        print(f"No running server found ({pid_file.name} not found)")
+        return 1
+
+    try:
+        pids = read_pids(pid_file)
+    except (ValueError, OSError) as e:
+        print(f"Invalid PID file: {e}")
+        pid_file.unlink(missing_ok=True)
+        return 1
+
+    vivos = [p for p in pids if alive(p)]
+    if not vivos:
+        print(f"No running server found (PID {', '.join(map(str, pids))} "
+              f"is not running; removed stale {pid_file.name})")
+        pid_file.unlink(missing_ok=True)
+        return 1
+
+    for pid in vivos:
+        terminate(pid, False)
+    restantes = _wait_until_dead(vivos, grace, alive)
+
+    if restantes:
+        # SIGTERM ignorado (POSIX). No Windows o taskkill /F ja e forcado.
+        for pid in restantes:
+            terminate(pid, True)
+        restantes = _wait_until_dead(restantes, 2.0, alive)
+
+    if restantes:
+        print(f"Could not stop the server: PID {', '.join(map(str, restantes))} "
+              f"is still running. Stop it manually.")
+        return 1
+
+    print(f"Server stopped (PID {', '.join(map(str, vivos))})")
+    pid_file.unlink(missing_ok=True)
+    return 0

quantum/cli/utils.py

@@ -0,0 +1,334 @@
+"""
+Quantum CLI Utilities
+
+Color output, progress bars, and common CLI helpers using rich.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from contextlib import contextmanager
+
+# Try to import rich, provide helpful error if missing
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+    from rich.syntax import Syntax
+    from rich.tree import Tree
+    from rich.text import Text
+    from rich.theme import Theme
+    from rich.markdown import Markdown
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+
+# Quantum theme colors
+QUANTUM_THEME = Theme({
+    "info": "cyan",
+    "success": "green",
+    "warning": "yellow",
+    "error": "bold red",
+    "highlight": "bold magenta",
+    "dim": "dim white",
+    "command": "bold blue",
+    "path": "underline cyan",
+})
+
+
+class QuantumConsole:
+    """Rich console wrapper for Quantum CLI output."""
+
+    def __init__(self, quiet: bool = False, no_color: bool = False):
+        """Initialize console with optional quiet/no-color modes."""
+        self.quiet = quiet
+        self.no_color = no_color or os.environ.get('NO_COLOR', '') != ''
+
+        if RICH_AVAILABLE:
+            self.console = Console(
+                theme=QUANTUM_THEME,
+                force_terminal=not no_color,
+                no_color=no_color
+            )
+        else:
+            self.console = None
+
+    def _fallback_print(self, message: str, prefix: str = ""):
+        """Fallback print when rich is not available."""
+        if prefix:
+            print(f"[{prefix}] {message}")
+        else:
+            print(message)
+
+    def info(self, message: str) -> None:
+        """Print info message."""
+        if self.quiet:
+            return
+        if self.console:
+            self.console.print(f"[info][INFO][/info] {message}")
+        else:
+            self._fallback_print(message, "INFO")
+
+    def success(self, message: str) -> None:
+        """Print success message."""
+        if self.console:
+            self.console.print(f"[success][SUCCESS][/success] {message}")
+        else:
+            self._fallback_print(message, "SUCCESS")
+
+    def warning(self, message: str) -> None:
+        """Print warning message."""
+        if self.console:
+            self.console.print(f"[warning][WARNING][/warning] {message}")
+        else:
+            self._fallback_print(message, "WARNING")
+
+    def error(self, message: str) -> None:
+        """Print error message."""
+        if self.console:
+            self.console.print(f"[error][ERROR][/error] {message}", style="error")
+        else:
+            self._fallback_print(message, "ERROR")
+
+    def print(self, message: str = "", style: Optional[str] = None) -> None:
+        """Print generic message."""
+        if self.quiet:
+            return
+        if self.console:
+            self.console.print(message, style=style)
+        else:
+            print(message)
+
+    def header(self, title: str, subtitle: Optional[str] = None) -> None:
+        """Print header with title and optional subtitle."""
+        if self.quiet:
+            return
+        if self.console:
+            text = f"[bold magenta]{title}[/bold magenta]"
+            if subtitle:
+                text += f"\n[dim]{subtitle}[/dim]"
+            self.console.print(Panel(text, border_style="magenta"))
+        else:
+            print(f"\n=== {title} ===")
+            if subtitle:
+                print(f"    {subtitle}")
+            print()
+
+    def panel(self, content: str, title: Optional[str] = None, style: str = "blue") -> None:
+        """Print content in a panel."""
+        if self.quiet:
+            return
+        if self.console:
+            self.console.print(Panel(content, title=title, border_style=style))
+        else:
+            if title:
+                print(f"\n--- {title} ---")
+            print(content)
+            print()
+
+    def table(self, headers: List[str], rows: List[List[str]], title: Optional[str] = None) -> None:
+        """Print a table."""
+        if self.console:
+            table = Table(title=title, show_header=True, header_style="bold cyan")
+            for header in headers:
+                table.add_column(header)
+            for row in rows:
+                table.add_row(*row)
+            self.console.print(table)
+        else:
+            if title:
+                print(f"\n{title}")
+            # Simple table fallback
+            col_widths = [max(len(str(row[i])) for row in [headers] + rows) for i in range(len(headers))]
+            header_line = " | ".join(h.ljust(w) for h, w in zip(headers, col_widths))
+            print(header_line)
+            print("-" * len(header_line))
+            for row in rows:
+                print(" | ".join(str(c).ljust(w) for c, w in zip(row, col_widths)))
+
+    def tree(self, label: str, items: Dict[str, Any]) -> None:
+        """Print a tree structure."""
+        if self.console:
+            tree = Tree(f"[bold]{label}[/bold]")
+            self._build_tree(tree, items)
+            self.console.print(tree)
+        else:
+            print(f"{label}")
+            self._print_tree_fallback(items, indent=2)
+
+    def _build_tree(self, parent, items: Dict[str, Any]) -> None:
+        """Recursively build tree."""
+        for key, value in items.items():
+            if isinstance(value, dict):
+                branch = parent.add(f"[cyan]{key}/[/cyan]")
+                self._build_tree(branch, value)
+            elif isinstance(value, list):
+                branch = parent.add(f"[cyan]{key}/[/cyan]")
+                for item in value:
+                    if isinstance(item, dict):
+                        self._build_tree(branch, item)
+                    else:
+                        branch.add(str(item))
+            else:
+                parent.add(f"{key}: [dim]{value}[/dim]")
+
+    def _print_tree_fallback(self, items: Dict[str, Any], indent: int = 0) -> None:
+        """Fallback tree printing."""
+        for key, value in items.items():
+            if isinstance(value, dict):
+                print(" " * indent + f"{key}/")
+                self._print_tree_fallback(value, indent + 2)
+            elif isinstance(value, list):
+                print(" " * indent + f"{key}/")
+                for item in value:
+                    print(" " * (indent + 2) + str(item))
+            else:
+                print(" " * indent + f"{key}: {value}")
+
+    def code(self, code: str, language: str = "xml", title: Optional[str] = None) -> None:
+        """Print syntax-highlighted code."""
+        if self.quiet:
+            return
+        if self.console:
+            syntax = Syntax(code, language, theme="monokai", line_numbers=True)
+            if title:
+                self.console.print(Panel(syntax, title=title, border_style="green"))
+            else:
+                self.console.print(syntax)
+        else:
+            if title:
+                print(f"\n--- {title} ---")
+            print(code)
+
+    @contextmanager
+    def progress(self, description: str = "Working...", total: Optional[int] = None):
+        """Context manager for progress indication."""
+        if self.quiet or not self.console:
+            yield None
+            return
+
+        if total:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                console=self.console
+            ) as progress:
+                task = progress.add_task(description, total=total)
+                yield lambda n=1: progress.update(task, advance=n)
+        else:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=self.console
+            ) as progress:
+                task = progress.add_task(description, total=None)
+                yield lambda: None
+
+    def spinner(self, description: str = "Working..."):
+        """Create a spinner context manager."""
+        if self.quiet or not self.console:
+            @contextmanager
+            def noop():
+                yield
+            return noop()
+
+        return self.console.status(description, spinner="dots")
+
+
+# Global console instance
+console = QuantumConsole()
+
+
+def get_console(quiet: bool = False, no_color: bool = False) -> QuantumConsole:
+    """Get a configured console instance."""
+    return QuantumConsole(quiet=quiet, no_color=no_color)
+
+
+def validate_project_name(name: str) -> tuple[bool, str]:
+    """Validate project name.
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    import re
+
+    if not name:
+        return False, "Project name cannot be empty"
+
+    if len(name) < 2:
+        return False, "Project name must be at least 2 characters"
+
+    if len(name) > 50:
+        return False, "Project name must be 50 characters or less"
+
+    if not re.match(r'^[a-zA-Z][a-zA-Z0-9_-]*$', name):
+        return False, "Project name must start with a letter and contain only letters, numbers, underscores, and hyphens"
+
+    # Check for reserved names
+    reserved = ['quantum', 'src', 'dist', 'build', 'node_modules', 'test', 'tests']
+    if name.lower() in reserved:
+        return False, f"'{name}' is a reserved name"
+
+    return True, ""
+
+
+def find_project_root() -> Optional[Path]:
+    """Find the project root by looking for quantum.config.yaml or .q files."""
+    current = Path.cwd()
+
+    # Check current and parent directories
+    for path in [current] + list(current.parents):
+        if (path / 'quantum.config.yaml').exists():
+            return path
+        if list(path.glob('*.q')):
+            return path
+        # Stop at home directory
+        if path == Path.home():
+            break
+
+    return None
+
+
+def find_q_files(path: Path, recursive: bool = True) -> List[Path]:
+    """Find all .q files in a directory."""
+    if recursive:
+        return list(path.rglob('*.q'))
+    return list(path.glob('*.q'))
+
+
+def get_quantum_version() -> str:
+    """Get Quantum version from package or default."""
+    try:
+        # Try to read from version file
+        version_file = Path(__file__).parent.parent / '__version__.py'
+        if version_file.exists():
+            content = version_file.read_text()
+            # Parse version = "x.y.z"
+            for line in content.splitlines():
+                if line.startswith('version'):
+                    return line.split('=')[1].strip().strip('"\'')
+    except Exception:
+        pass
+
+    return "1.0.0-dev"
+
+
+def ensure_dependencies(*packages: str) -> bool:
+    """Check if required packages are installed."""
+    missing = []
+    for pkg in packages:
+        try:
+            __import__(pkg.replace('-', '_'))
+        except ImportError:
+            missing.append(pkg)
+
+    if missing:
+        console.error(f"Missing dependencies: {', '.join(missing)}")
+        console.info(f"Install with: pip install {' '.join(missing)}")
+        return False
+    return True

quantum/compiler/__init__.py

@@ -0,0 +1,30 @@
+"""
+Quantum Transpiler
+==================
+
+Transpiles Quantum (.q) files to native Python and JavaScript code.
+
+Usage:
+    from quantum.compiler import Transpiler
+
+    transpiler = Transpiler(target='python')
+    result = transpiler.compile_file('app.q')
+    print(result.code)
+
+CLI:
+    quantum compile app.q -o app.py
+    quantum compile app.q -o app.js --target=javascript
+"""
+
+from .transpiler import Transpiler, CompilationResult
+from .base_generator import CodeGenerator
+from .expression_transformer import ExpressionTransformer
+
+__all__ = [
+    'Transpiler',
+    'CompilationResult',
+    'CodeGenerator',
+    'ExpressionTransformer',
+]
+
+__version__ = '1.0.0'