quantum-framework 0.9.0__py3-none-any.whl

quantum/runtime/executors/messaging/queue_executor.py

@@ -0,0 +1,103 @@
+"""
+Queue Executor - Execute q:queue statements
+
+Handles queue/exchange management operations.
+"""
+
+from typing import Any, List, Dict, Type
+from quantum.runtime.executors.base import BaseExecutor, ExecutorError
+from quantum.core.ast_nodes import QueueNode
+
+
+class QueueExecutor(BaseExecutor):
+    """
+    Executor for q:queue statements.
+
+    Supports:
+    - Queue declaration
+    - Queue purge
+    - Queue deletion
+    - Queue info retrieval
+    - Dead letter queue configuration
+    """
+
+    @property
+    def handles(self) -> List[Type]:
+        return [QueueNode]
+
+    def execute(self, node: QueueNode, exec_context) -> Any:
+        """
+        Execute queue management operation.
+
+        Args:
+            node: QueueNode with queue configuration
+            exec_context: Execution context
+
+        Returns:
+            Queue operation result dict
+        """
+        try:
+            context = exec_context.get_all_variables()
+
+            # Resolve queue name
+            queue_name = self.apply_databinding(node.name, context)
+
+            # Execute based on action
+            if node.action == 'declare':
+                result = self._execute_declare(node, queue_name, context)
+            elif node.action == 'purge':
+                result = self._execute_purge(queue_name)
+            elif node.action == 'delete':
+                result = self._execute_delete(queue_name)
+            elif node.action == 'info':
+                result = self._execute_info(queue_name)
+            else:
+                raise ExecutorError(f"Unknown queue action: {node.action}")
+
+            # Store result
+            result_var = node.result if hasattr(node, 'result') and node.result else f"{queue_name}_result"
+            exec_context.set_variable(result_var, result, scope="component")
+
+            return result
+
+        except Exception as e:
+            raise ExecutorError(f"Queue operation error: {e}")
+
+    def _execute_declare(self, node: QueueNode, queue_name: str, context: Dict[str, Any]) -> Dict:
+        """Declare a queue with configuration."""
+        # Build queue options
+        options = {
+            'durable': getattr(node, 'durable', True),
+            'exclusive': getattr(node, 'exclusive', False),
+            'auto_delete': getattr(node, 'auto_delete', False)
+        }
+
+        # Dead letter queue
+        if hasattr(node, 'dead_letter') and node.dead_letter:
+            dlq = self.apply_databinding(node.dead_letter, context)
+            options['dead_letter_queue'] = dlq
+
+        # TTL
+        if hasattr(node, 'ttl') and node.ttl:
+            options['ttl'] = int(node.ttl)
+
+        # Max length
+        if hasattr(node, 'max_length') and node.max_length:
+            options['max_length'] = int(node.max_length)
+
+        return self.services.message_queue.declare_queue(
+            name=queue_name,
+            **options
+        )
+
+    def _execute_purge(self, queue_name: str) -> Dict:
+        """Purge all messages from a queue."""
+        return self.services.message_queue.purge_queue(queue_name)
+
+    def _execute_delete(self, queue_name: str) -> Dict:
+        """Delete a queue."""
+        return self.services.message_queue.delete_queue(queue_name)
+
+    def _execute_info(self, queue_name: str) -> Dict:
+        """Get queue information."""
+        return self.services.message_queue.get_queue_info(queue_name)

quantum/runtime/executors/messaging/websocket_executor.py

@@ -0,0 +1,197 @@
+"""
+WebSocket Executor - Execute q:websocket statements
+
+Handles WebSocket connection management and messaging.
+"""
+
+from typing import Any, List, Dict, Type
+from quantum.runtime.executors.base import BaseExecutor, ExecutorError
+
+# Import from features module
+try:
+    from quantum.core.features.websocket.src.ast_node import (
+        WebSocketNode, WebSocketSendNode, WebSocketCloseNode
+    )
+except ImportError:
+    from quantum.core.features.websocket.src import (
+        WebSocketNode, WebSocketSendNode, WebSocketCloseNode
+    )
+
+
+class WebSocketExecutor(BaseExecutor):
+    """
+    Executor for q:websocket statements.
+
+    Supports:
+    - WebSocket connection creation
+    - Auto-connect and reconnection
+    - Event handlers (on-connect, on-message, on-error, on-close)
+    - Heartbeat/ping-pong
+    """
+
+    @property
+    def handles(self) -> List[Type]:
+        return [WebSocketNode]
+
+    def execute(self, node: WebSocketNode, exec_context) -> Any:
+        """
+        Execute WebSocket connection creation.
+
+        Args:
+            node: WebSocketNode with WebSocket configuration
+            exec_context: Execution context
+
+        Returns:
+            WebSocket connection info dict
+        """
+        try:
+            context = exec_context.get_all_variables()
+
+            # Resolve URL
+            url = self.apply_databinding(node.url, context)
+
+            # register_handler() expects a callable, not a config dict —
+            # build a closure per event that runs the handler's AST body
+            # with the incoming event payload bound as local variables.
+            handlers = {}
+            for handler in node.handlers:
+                handlers[handler.event] = self._build_event_handler(handler.body)
+
+            # Handlers first, connection second. Handlers are keyed by
+            # connection NAME, so registering them early is safe — and with a
+            # real transport, autoConnect opens the socket inside
+            # register_connection and fires on-connect immediately. Register
+            # after, and that first event is dispatched to nobody.
+            for event, handler in handlers.items():
+                self.services.websocket.register_handler(node.name, event, handler)
+
+            # WebSocketService.register_connection() takes (name, url,
+            # metadata) — there is no create_connection(). Connection options
+            # ride along as metadata; auto_connect there decides whether a
+            # socket is actually opened.
+            connection = self.services.websocket.register_connection(
+                name=node.name,
+                url=url,
+                metadata={
+                    'auto_connect': node.auto_connect,
+                    'reconnect': node.reconnect,
+                    'reconnect_delay': node.reconnect_delay,
+                    'max_reconnects': node.max_reconnects,
+                    'heartbeat': node.heartbeat,
+                    'protocols': node.protocols.split(',') if node.protocols else [],
+                },
+            )
+
+            result = connection.to_dict()
+
+            # Store connection reference
+            exec_context.set_variable(node.name, result, scope="component")
+
+            return result
+
+        except Exception as e:
+            exec_context.set_variable(node.name, {
+                'connected': False,
+                'error': str(e),
+                'url': node.url
+            }, scope="component")
+            raise ExecutorError(f"WebSocket creation error: {e}")
+
+    def _build_event_handler(self, body):
+        """Build a callable for WebSocketService.register_handler().
+
+        The service calls handlers with the event payload dict; that payload
+        is bound as local variables so the handler body can reference it.
+        """
+        def handle_event(event_data=None):
+            variables = event_data if isinstance(event_data, dict) else {'event': event_data}
+            return self.run_body_in_child_context(body, variables)
+
+        return handle_event
+
+
+class WebSocketSendExecutor(BaseExecutor):
+    """
+    Executor for q:websocket-send statements.
+
+    Sends messages through an existing WebSocket connection.
+    """
+
+    @property
+    def handles(self) -> List[Type]:
+        return [WebSocketSendNode]
+
+    def execute(self, node: WebSocketSendNode, exec_context) -> Any:
+        """
+        Execute WebSocket message send.
+
+        Args:
+            node: WebSocketSendNode with send configuration
+            exec_context: Execution context
+
+        Returns:
+            Send result dict
+        """
+        try:
+            context = exec_context.get_all_variables()
+
+            # Resolve message
+            message = self.apply_databinding(node.message, context)
+
+            # Get connection
+            connection = node.connection
+
+            # Send message
+            sent = self.services.websocket.send_message(
+                connection_name=connection,
+                data=message,
+                msg_type=node.type or 'text',
+            )
+
+            return {'connection': connection, 'sent': sent}
+
+        except Exception as e:
+            raise ExecutorError(f"WebSocket send error: {e}")
+
+
+class WebSocketCloseExecutor(BaseExecutor):
+    """
+    Executor for q:websocket-close statements.
+
+    Closes an existing WebSocket connection.
+    """
+
+    @property
+    def handles(self) -> List[Type]:
+        return [WebSocketCloseNode]
+
+    def execute(self, node: WebSocketCloseNode, exec_context) -> Any:
+        """
+        Execute WebSocket connection close.
+
+        Args:
+            node: WebSocketCloseNode with close configuration
+            exec_context: Execution context
+
+        Returns:
+            Close result dict
+        """
+        try:
+            context = exec_context.get_all_variables()
+
+            # Resolve reason if provided
+            reason = ""
+            if node.reason:
+                reason = self.apply_databinding(node.reason, context)
+
+            # Close connection
+            self.services.websocket.close_connection(
+                connection_name=node.connection,
+                code=node.code,
+                reason=reason,
+            )
+
+            return {'connection': node.connection, 'closed': True, 'code': node.code}
+
+        except Exception as e:
+            raise ExecutorError(f"WebSocket close error: {e}")

quantum/runtime/executors/scripting/__init__.py

@@ -0,0 +1,11 @@
+"""
+Scripting Executors
+
+Executors for Python scripting: python, pyimport, pyclass.
+"""
+
+from .python_executor import PythonExecutor
+from .pyimport_executor import PyImportExecutor
+from .pyclass_executor import PyClassExecutor
+
+__all__ = ['PythonExecutor', 'PyImportExecutor', 'PyClassExecutor']

quantum/runtime/executors/scripting/pyclass_executor.py

@@ -0,0 +1,90 @@
+"""
+PyClass Executor - Execute q:class statements
+
+Handles inline Python class definitions.
+"""
+
+from typing import Any, List, Dict, Type
+from quantum.runtime.executors.base import BaseExecutor, ExecutorError
+from quantum.runtime.executors.scripting.python_executor import (
+    normalise_python_source,
+)
+from quantum.core.ast_nodes import PyClassNode
+
+
+class PyClassExecutor(BaseExecutor):
+    """
+    Executor for q:class statements.
+
+    Supports:
+    - Inline class definition
+    - Base class inheritance
+    - Decorator application
+    """
+
+    @property
+    def handles(self) -> List[Type]:
+        return [PyClassNode]
+
+    def execute(self, node: PyClassNode, exec_context) -> Any:
+        """
+        Execute Python class definition.
+
+        Args:
+            node: PyClassNode with class configuration
+            exec_context: Execution context
+
+        Returns:
+            Defined class
+        """
+        try:
+            self.require_python_scripting('q:pyclass')
+
+            context = exec_context.get_all_variables()
+
+            # Build namespace with existing variables
+            namespace = dict(context)
+
+            # Resolve base classes
+            bases = []
+            for base_name in node.bases:
+                if base_name in namespace:
+                    bases.append(namespace[base_name])
+                else:
+                    # Try to import/eval the base class
+                    try:
+                        base = eval(base_name, namespace)
+                        bases.append(base)
+                    except:
+                        raise ExecutorError(f"Base class '{base_name}' not found")
+
+            if not bases:
+                bases = [object]
+
+            # Build class body. The source is dedented for the same reason
+            # q:python's is: markup-indented code raised "unexpected indent"
+            # on line 2, which is every class body written inside XML.
+            class_body = {}
+            exec(normalise_python_source(node.code), namespace, class_body)
+
+            # Create the class
+            cls = type(node.name, tuple(bases), class_body)
+
+            # Apply decorators (in reverse order)
+            for decorator_name in reversed(node.decorators):
+                if decorator_name in namespace:
+                    decorator = namespace[decorator_name]
+                else:
+                    try:
+                        decorator = eval(decorator_name, namespace)
+                    except:
+                        raise ExecutorError(f"Decorator '{decorator_name}' not found")
+                cls = decorator(cls)
+
+            # Store class in context
+            exec_context.set_variable(node.name, cls, scope="component")
+
+            return cls
+
+        except Exception as e:
+            raise ExecutorError(f"PyClass execution error: {e}")

quantum/runtime/executors/scripting/pyimport_executor.py

@@ -0,0 +1,81 @@
+"""
+PyImport Executor - Execute q:pyimport statements
+
+Handles Python module imports.
+"""
+
+from typing import Any, List, Dict, Type
+from quantum.runtime.executors.base import BaseExecutor, ExecutorError
+from quantum.core.ast_nodes import PyImportNode
+
+
+class PyImportExecutor(BaseExecutor):
+    """
+    Executor for q:pyimport statements.
+
+    Supports:
+    - Module import with alias
+    - Specific name imports (from X import Y)
+    - Star imports (from X import *)
+    """
+
+    @property
+    def handles(self) -> List[Type]:
+        return [PyImportNode]
+
+    def execute(self, node: PyImportNode, exec_context) -> Any:
+        """
+        Execute Python import.
+
+        Args:
+            node: PyImportNode with import configuration
+            exec_context: Execution context
+
+        Returns:
+            Imported module or names
+        """
+        try:
+            self.require_python_scripting('q:pyimport')
+
+            import importlib
+
+            # Import the module
+            module = importlib.import_module(node.module)
+
+            # Handle different import styles
+            if node.alias:
+                # import X as Y
+                exec_context.set_variable(node.alias, module, scope="component")
+                return module
+
+            elif node.names:
+                # from X import Y, Z
+                imported = {}
+                for name in node.names:
+                    name = name.strip()
+                    if name == '*':
+                        # Import all public names
+                        for attr_name in dir(module):
+                            if not attr_name.startswith('_'):
+                                attr = getattr(module, attr_name)
+                                exec_context.set_variable(attr_name, attr, scope="component")
+                                imported[attr_name] = attr
+                    else:
+                        attr = getattr(module, name)
+                        exec_context.set_variable(name, attr, scope="component")
+                        imported[name] = attr
+                return imported
+
+            else:
+                # import X
+                # Use last part of module name
+                module_name = node.module.split('.')[-1]
+                exec_context.set_variable(module_name, module, scope="component")
+                return module
+
+        except ImportError as e:
+            raise ExecutorError(f"Import error: Cannot import '{node.module}': {e}")
+        except AttributeError as e:
+            raise ExecutorError(f"Import error: Module '{node.module}' has no attribute: {e}")
+        except Exception as e:
+            raise ExecutorError(f"PyImport execution error: {e}")