quantum-framework 0.9.0__py3-none-any.whl

quantum/core/features/dump/src/parser.py

@@ -0,0 +1,61 @@
+"""
+Parser for q:dump - Variable Inspection
+"""
+
+import xml.etree.ElementTree as ET
+from .ast_node import DumpNode
+
+
+def parse_dump(dump_element: ET.Element) -> DumpNode:
+    """
+    Parse a <q:dump> element into a DumpNode
+
+    Args:
+        dump_element: The XML element representing the dump statement
+
+    Returns:
+        DumpNode instance
+
+    Raises:
+        ValueError: If required attributes are missing or invalid
+    """
+    # Get required attribute
+    var = dump_element.get('var')
+
+    # Get optional attributes
+    label = dump_element.get('label')
+    format_str = dump_element.get('format', 'html')
+    depth_str = dump_element.get('depth', '10')
+    when = dump_element.get('when')
+    expand_str = dump_element.get('expand', '2')
+    show_types_str = dump_element.get('show_types', 'true')
+
+    # Parse depth
+    try:
+        depth = int(depth_str) if depth_str else 10
+    except ValueError:
+        depth = 10
+
+    # Parse expand
+    try:
+        expand = int(expand_str) if expand_str else 2
+    except ValueError:
+        expand = 2
+
+    # Parse show_types
+    show_types = show_types_str.lower() == 'true' if show_types_str else True
+
+    # Validate no child elements (q:dump should be self-closing)
+    if len(dump_element) > 0:
+        raise ValueError("Dump tag must be self-closing")
+
+    # Create and return DumpNode (validation happens in __init__)
+    return DumpNode(
+        var=var,
+        label=label,
+        format=format_str,
+        depth=depth,
+        when=when,
+        expand=expand,
+        show_types=show_types
+    )

quantum/core/features/dump/src/runtime.py

@@ -0,0 +1,246 @@
+"""
+Runtime service for q:dump - Variable Inspection
+"""
+
+import json
+from typing import Any, Dict, Set
+from html import escape
+
+
+class DumpService:
+    """
+    Service to handle variable inspection and formatted output
+
+    Phase 1 Features:
+    - HTML, JSON, and text output formats
+    - Depth limiting
+    - Type information
+    - Circular reference detection
+
+    Phase 2 Features (TODO):
+    - Rich library integration for beautiful output
+    - Expandable/collapsible trees
+    - Search within dumps
+    - Side-by-side comparison
+    - Custom themes
+    """
+
+    def __init__(self):
+        """Initialize the dump service"""
+        self._seen_objects: Set[int] = set()
+
+    def dump(
+        self,
+        var: Any,
+        label: str,
+        format: str = 'html',
+        depth: int = 10,
+        current_depth: int = 0
+    ) -> str:
+        """
+        Generate formatted dump output for a variable
+
+        Args:
+            var: Variable to inspect
+            label: Label for the dump
+            format: Output format (html, json, text)
+            depth: Maximum nesting depth
+            current_depth: Current recursion depth
+
+        Returns:
+            Formatted string output
+        """
+        # Reset seen objects for new dump
+        if current_depth == 0:
+            self._seen_objects = set()
+
+        if format == 'json':
+            return self._dump_json(var, label)
+        elif format == 'text':
+            return self._dump_text(var, label, depth, current_depth)
+        else:  # html (default)
+            return self._dump_html(var, label, depth, current_depth)
+
+    def _dump_json(self, var: Any, label: str) -> str:
+        """Dump as pretty-printed JSON"""
+        output = [f"=== {label} ==="]
+        try:
+            json_str = json.dumps(var, indent=2, default=str)
+            output.append(json_str)
+        except Exception as e:
+            output.append(f"Error dumping as JSON: {e}")
+            output.append(f"Type: {type(var).__name__}")
+            output.append(f"Value: {str(var)}")
+        return '\n'.join(output)
+
+    def _dump_text(
+        self,
+        var: Any,
+        label: str,
+        max_depth: int,
+        current_depth: int,
+        prefix: str = ''
+    ) -> str:
+        """Dump as plain text tree structure"""
+        if current_depth == 0:
+            output = [f"=== {label} ==="]
+        else:
+            output = []
+
+        # Check depth limit
+        if current_depth >= max_depth:
+            output.append(f"{prefix}... (max depth reached)")
+            return '\n'.join(output)
+
+        # Get type name
+        type_name = type(var).__name__
+
+        # Handle None/null
+        if var is None:
+            output.append(f"{prefix}{label} => null")
+            return '\n'.join(output)
+
+        # Handle primitives
+        if isinstance(var, (str, int, float, bool)):
+            if isinstance(var, str):
+                value_repr = f'"{var}"'
+            else:
+                value_repr = str(var).lower() if isinstance(var, bool) else str(var)
+            output.append(f"{prefix}{label} => {value_repr} ({type_name})")
+            return '\n'.join(output)
+
+        # Handle dictionaries/objects
+        if isinstance(var, dict):
+            output.append(f"{prefix}{label} (dict, {len(var)} items):")
+            for key, value in var.items():
+                sub_output = self._dump_text(
+                    value,
+                    str(key),
+                    max_depth,
+                    current_depth + 1,
+                    prefix + '  '
+                )
+                # Skip the header line for nested items
+                sub_lines = sub_output.split('\n')
+                if current_depth > 0 and sub_lines:
+                    output.extend(sub_lines)
+                else:
+                    output.append(sub_output)
+            return '\n'.join(output)
+
+        # Handle lists/arrays
+        if isinstance(var, (list, tuple)):
+            output.append(f"{prefix}{label} ({type_name}, {len(var)} items):")
+            for i, item in enumerate(var):
+                sub_output = self._dump_text(
+                    item,
+                    f"[{i}]",
+                    max_depth,
+                    current_depth + 1,
+                    prefix + '  '
+                )
+                sub_lines = sub_output.split('\n')
+                if current_depth > 0 and sub_lines:
+                    output.extend(sub_lines)
+                else:
+                    output.append(sub_output)
+            return '\n'.join(output)
+
+        # Handle other types
+        output.append(f"{prefix}{label} => {str(var)} ({type_name})")
+        return '\n'.join(output)
+
+    def _dump_html(
+        self,
+        var: Any,
+        label: str,
+        max_depth: int,
+        current_depth: int
+    ) -> str:
+        """Dump as HTML with styling"""
+        if current_depth == 0:
+            output = [
+                '<div class="quantum-dump" style="font-family: monospace; background: #f5f5f5; padding: 10px; margin: 10px 0; border: 1px solid #ddd; border-radius: 4px;">',
+                f'<h4 style="margin: 0 0 10px 0; color: #333;">{escape(label)}</h4>'
+            ]
+        else:
+            output = []
+
+        # Check depth limit
+        if current_depth >= max_depth:
+            output.append(f'<span style="color: #999;">... (max depth reached)</span>')
+            if current_depth == 0:
+                output.append('</div>')
+            return ''.join(output)
+
+        # Get type name
+        type_name = type(var).__name__
+
+        # Handle None/null
+        if var is None:
+            output.append('<span style="color: #999; font-style: italic;">null</span>')
+            if current_depth == 0:
+                output.append('</div>')
+            return ''.join(output)
+
+        # Handle primitives
+        if isinstance(var, bool):
+            color = '#008800' if var else '#cc0000'
+            output.append(f'<span style="color: {color}; font-weight: bold;">{str(var).lower()}</span>')
+            output.append(f' <span style="color: #999; font-size: 0.9em;">(boolean)</span>')
+        elif isinstance(var, (int, float)):
+            output.append(f'<span style="color: #0066cc; font-weight: bold;">{var}</span>')
+            output.append(f' <span style="color: #999; font-size: 0.9em;">({type_name})</span>')
+        elif isinstance(var, str):
+            output.append(f'<span style="color: #cc6600;">"{escape(var)}"</span>')
+            output.append(f' <span style="color: #999; font-size: 0.9em;">(string)</span>')
+        # Handle dictionaries/objects
+        elif isinstance(var, dict):
+            output.append(f'<span style="color: #999;">(dict, {len(var)} items)</span>')
+            output.append('<ul style="margin: 5px 0; padding-left: 20px; list-style: none;">')
+            for key, value in var.items():
+                output.append('<li style="margin: 2px 0;">')
+                output.append(f'<span style="color: #660066; font-weight: bold;">{escape(str(key))}</span>: ')
+                output.append(self._dump_html(value, '', max_depth, current_depth + 1))
+                output.append('</li>')
+            output.append('</ul>')
+        # Handle lists/arrays
+        elif isinstance(var, (list, tuple)):
+            output.append(f'<span style="color: #999;">({type_name}, {len(var)} items)</span>')
+            output.append('<ul style="margin: 5px 0; padding-left: 20px; list-style: none;">')
+            for i, item in enumerate(var):
+                output.append('<li style="margin: 2px 0;">')
+                output.append(f'<span style="color: #660066; font-weight: bold;">[{i}]</span>: ')
+                output.append(self._dump_html(item, '', max_depth, current_depth + 1))
+                output.append('</li>')
+            output.append('</ul>')
+        # Handle other types
+        else:
+            output.append(f'<span style="color: #666;">{escape(str(var))}</span>')
+            output.append(f' <span style="color: #999; font-size: 0.9em;">({type_name})</span>')
+
+        if current_depth == 0:
+            output.append('</div>')
+
+        return ''.join(output)
+
+    def should_dump(self, condition: Any) -> bool:
+        """
+        Evaluate if dumping should occur based on 'when' condition
+
+        Args:
+            condition: Evaluated condition value
+
+        Returns:
+            True if should dump, False otherwise
+        """
+        # If no condition, always dump
+        if condition is None:
+            return True
+
+        # Evaluate boolean condition
+        if isinstance(condition, bool):
+            return condition
+
+        # Truthy evaluation for other types
+        return bool(condition)

quantum/core/features/functions/src/__init__.py

@@ -0,0 +1,8 @@
+"""
+Functions Feature (q:function)
+"""
+
+from .ast_node import FunctionNode, RestConfig
+
+__all__ = ['FunctionNode', 'RestConfig']
+__version__ = '1.0.0'

quantum/core/features/functions/src/ast_node.py

@@ -0,0 +1,149 @@
+"""
+AST Node for Functions (q:function)
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+
+# Import base class
+import sys
+from pathlib import Path
+from quantum.core.ast_nodes import QuantumNode, QuantumParam
+
+
+@dataclass
+class RestConfig:
+    """REST configuration for a function - OPTIONAL"""
+    # Required (if REST enabled)
+    endpoint: str
+    method: str = "GET"
+
+    # Optional (with sensible defaults)
+    produces: str = "application/json"
+    consumes: str = "application/json"
+    auth: Optional[str] = None       # None = no auth, or: bearer, basic, apikey
+    roles: List[str] = None          # None = no role check
+    rate_limit: Optional[str] = None # "100/minute"
+    cors: bool = False
+    status: int = 200                # Default status code
+
+    def __post_init__(self):
+        if self.roles is None:
+            self.roles = []
+
+
+class FunctionNode(QuantumNode):
+    """Represents a <q:function>"""
+
+    def __init__(self, name: str):
+        # ========== CORE (required) ==========
+        self.name = name
+        self.return_type = "any"
+        self.scope = "component"  # component, global, api
+        self.access = "public"    # public, private, protected
+        self.params: List[QuantumParam] = []
+        self.body: List[QuantumNode] = []
+
+        # ========== OPTIONAL LAYERS ==========
+
+        # Layer 1: Documentation
+        self.description = None
+        self.hint = None
+
+        # Layer 2: Validation
+        self.validate_params = False  # Auto-validate params
+
+        # Layer 3: Performance
+        self.cache = False
+        self.cache_ttl = None  # seconds
+        self.memoize = False
+        self.pure = False
+
+        # Layer 4: Behavior
+        self.async_func = False
+        self.retry = 0
+        self.timeout = None  # seconds
+
+        # Layer 5: REST API (completely optional)
+        self.rest_config: Optional[RestConfig] = None
+
+        # Back-reference to container
+        self.container: Optional['ComponentNode'] = None
+
+    def is_rest_enabled(self) -> bool:
+        """Check if function has REST configuration"""
+        return self.rest_config is not None
+
+    def enable_rest(self, endpoint: str, method: str = "GET"):
+        """Enable REST for this function"""
+        self.rest_config = RestConfig(
+            endpoint=endpoint,
+            method=method
+        )
+
+    def is_private(self) -> bool:
+        """Check if function is private (starts with _ or access=private)"""
+        return self.access == "private" or self.name.startswith('_')
+
+    def add_param(self, param: QuantumParam):
+        """Add parameter to function"""
+        self.params.append(param)
+
+    def add_statement(self, statement: QuantumNode):
+        """Add statement to function body"""
+        self.body.append(statement)
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "type": "function",
+            "name": self.name,
+            "return_type": self.return_type,
+            "scope": self.scope,
+            "access": self.access,
+            "params_count": len(self.params),
+            "body_statements": len(self.body),
+            "description": self.description,
+            "validate_params": self.validate_params,
+            "cache": self.cache,
+            "memoize": self.memoize,
+            "pure": self.pure,
+            "async": self.async_func,
+            "retry": self.retry,
+            "timeout": self.timeout
+        }
+
+        if self.rest_config:
+            result["rest"] = {
+                "endpoint": self.rest_config.endpoint,
+                "method": self.rest_config.method,
+                "produces": self.rest_config.produces,
+                "consumes": self.rest_config.consumes,
+                "auth": self.rest_config.auth,
+                "roles": self.rest_config.roles,
+                "status": self.rest_config.status
+            }
+
+        return result
+
+    def validate(self) -> List[str]:
+        errors = []
+
+        if not self.name:
+            errors.append("Function name is required")
+
+        # Validate params
+        for param in self.params:
+            errors.extend(param.validate())
+
+        # Validate body
+        for statement in self.body:
+            errors.extend(statement.validate())
+
+        # Validate REST config if present
+        if self.rest_config:
+            if not self.rest_config.endpoint:
+                errors.append("REST endpoint is required when REST is enabled")
+            if self.rest_config.method not in ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS']:
+                errors.append(f"Invalid HTTP method: {self.rest_config.method}")
+
+        return errors

quantum/core/features/game_engine_2d/src/__init__.py

@@ -0,0 +1,19 @@
+"""
+Game Engine 2D - AST nodes and parser for the qg: namespace.
+"""
+
+from .ast_nodes import (
+    SceneNode, SpriteNode, PhysicsNode, ColliderNode, AnimationNode,
+    OnCollisionNode, CameraNode, InputNode, SoundNode, ParticleNode, TimerNode,
+    SpawnNode, HudNode, TweenNode, TilemapNode, TilemapLayerNode,
+    BehaviorNode, UseNode, PrefabNode, InstanceNode, GroupNode,
+    StateMachineNode, StateNode, TransitionNode,
+)
+
+__all__ = [
+    'SceneNode', 'SpriteNode', 'PhysicsNode', 'ColliderNode', 'AnimationNode',
+    'OnCollisionNode', 'CameraNode', 'InputNode', 'SoundNode', 'ParticleNode', 'TimerNode',
+    'SpawnNode', 'HudNode', 'TweenNode', 'TilemapNode', 'TilemapLayerNode',
+    'BehaviorNode', 'UseNode', 'PrefabNode', 'InstanceNode', 'GroupNode',
+    'StateMachineNode', 'StateNode', 'TransitionNode',
+]