quantum-framework 0.9.0__py3-none-any.whl

quantum/core/parsers/html/html_parser.py

@@ -0,0 +1,115 @@
+"""
+HTML Parser - Parse HTML elements
+
+Handles parsing of standard HTML elements within Quantum components.
+"""
+
+from typing import List, Optional
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser
+from quantum.core.ast_nodes import HTMLNode, TextNode, HTML_VOID_ELEMENTS
+
+
+class HTMLParser(BaseTagParser):
+    """
+    Parser for HTML elements.
+
+    Handles standard HTML tags like div, span, p, a, etc.
+    This parser is used as a fallback for elements that aren't
+    Quantum-specific tags.
+    """
+
+    # Common HTML tags (not exhaustive - uses detection logic)
+    HTML_TAGS = {
+        'div', 'span', 'p', 'a', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+        'ul', 'ol', 'li', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
+        'form', 'input', 'button', 'select', 'option', 'textarea', 'label',
+        'img', 'video', 'audio', 'source', 'canvas', 'svg',
+        'header', 'footer', 'nav', 'main', 'section', 'article', 'aside',
+        'br', 'hr', 'pre', 'code', 'blockquote', 'em', 'strong', 'b', 'i',
+        'script', 'style', 'link', 'meta', 'head', 'body', 'html',
+    }
+
+    @property
+    def tag_names(self) -> List[str]:
+        """HTML parser handles all HTML tags."""
+        return list(self.HTML_TAGS)
+
+    def parse(self, element: ET.Element) -> HTMLNode:
+        """
+        Parse HTML element.
+
+        Args:
+            element: XML element representing HTML tag
+
+        Returns:
+            HTMLNode AST node
+        """
+        tag_name = self._get_local_name(element)
+
+        # Get attributes
+        attributes = dict(element.attrib)
+
+        # Check if void element
+        is_void = tag_name.lower() in HTML_VOID_ELEMENTS
+
+        # Create HTML node
+        html_node = HTMLNode(tag_name, attributes)
+
+        # Parse children if not void element
+        if not is_void:
+            html_node.children = self._parse_children(element)
+
+        return html_node
+
+    def _get_local_name(self, element: ET.Element) -> str:
+        """Extract local name from element tag."""
+        tag = element.tag
+        if '}' in tag:
+            return tag.split('}')[1]
+        if ':' in tag:
+            return tag.split(':')[1]
+        return tag
+
+    def _parse_children(self, element: ET.Element) -> List:
+        """Parse child elements and text."""
+        children = []
+
+        # Add leading text if present
+        if element.text and element.text.strip():
+            children.append(TextNode(element.text))
+
+        # Parse child elements
+        for child in element:
+            # Use main parser to handle child
+            child_node = self.parse_statement(child)
+            if child_node:
+                children.append(child_node)
+
+            # Add tail text after child
+            if child.tail and child.tail.strip():
+                children.append(TextNode(child.tail))
+
+        return children
+
+    def can_parse(self, tag_name: str) -> bool:
+        """
+        Check if this parser can handle the tag.
+
+        Uses heuristics to detect HTML elements:
+        1. Known HTML tags
+        2. Lowercase tags (not Quantum q: or component PascalCase)
+        """
+        if not tag_name:
+            return False
+
+        # Lowercase and in known tags
+        lower_tag = tag_name.lower()
+        if lower_tag in self.HTML_TAGS:
+            return True
+
+        # Lowercase first letter (not a component)
+        if tag_name[0].islower():
+            return True
+
+        return False

quantum/core/parsers/jobs/__init__.py

@@ -0,0 +1,11 @@
+"""
+Jobs Parsers
+
+Parsers for job operations: schedule, thread, job.
+"""
+
+from .schedule_parser import ScheduleParser
+from .thread_parser import ThreadParser
+from .job_parser import JobParser
+
+__all__ = ['ScheduleParser', 'ThreadParser', 'JobParser']

quantum/core/parsers/jobs/job_parser.py

@@ -0,0 +1,71 @@
+"""
+Job Parser - Parse q:job statements
+
+Handles job queue configuration.
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser, ParserError
+from quantum.core.ast_nodes import JobNode, QuantumParam
+
+
+class JobParser(BaseTagParser):
+    """
+    Parser for q:job statements.
+
+    Supports:
+    - Job definition
+    - Job dispatch
+    - Batch dispatch
+    - Retry configuration
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['job']
+
+    def parse(self, element: ET.Element) -> JobNode:
+        """
+        Parse q:job statement.
+
+        Args:
+            element: XML element for q:job
+
+        Returns:
+            JobNode AST node
+        """
+        name = self.get_attr(element, 'name')
+
+        if not name:
+            raise ParserError("Job requires 'name' attribute")
+
+        queue = self.get_attr(element, 'queue', 'default')
+        action = self.get_attr(element, 'action', 'define')
+
+        job_node = JobNode(name, queue, action)
+        job_node.delay = self.get_attr(element, 'delay')
+        job_node.priority = self.get_int_attr(element, 'priority', 0)
+        job_node.attempts = self.get_int_attr(element, 'attempts', 3)
+        job_node.backoff = self.get_attr(element, 'backoff', '30s')
+        job_node.timeout = self.get_attr(element, 'timeout')
+
+        # Parse children
+        for child in element:
+            child_type = self.get_element_name(child)
+
+            if child_type == 'param':
+                param = QuantumParam(
+                    self.get_attr(child, 'name', ''),
+                    self.get_attr(child, 'type', 'string')
+                )
+                param.value = self.get_attr(child, 'value')
+                param.required = self.get_bool_attr(child, 'required', False)
+                job_node.add_param(param)
+            else:
+                # Job body statement
+                statement = self.parse_statement(child)
+                if statement:
+                    job_node.add_statement(statement)
+
+        return job_node

quantum/core/parsers/jobs/schedule_parser.py

@@ -0,0 +1,62 @@
+"""
+Schedule Parser - Parse q:schedule statements
+
+Handles scheduled task configuration.
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser, ParserError
+from quantum.core.ast_nodes import ScheduleNode
+
+
+class ScheduleParser(BaseTagParser):
+    """
+    Parser for q:schedule statements.
+
+    Supports:
+    - Interval scheduling
+    - Cron expressions
+    - One-time execution
+    - Timezone support
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['schedule']
+
+    def parse(self, element: ET.Element) -> ScheduleNode:
+        """
+        Parse q:schedule statement.
+
+        Args:
+            element: XML element for q:schedule
+
+        Returns:
+            ScheduleNode AST node
+        """
+        name = self.get_attr(element, 'name')
+
+        if not name:
+            raise ParserError("Schedule requires 'name' attribute")
+
+        schedule_node = ScheduleNode(
+            name=name,
+            action=self.get_attr(element, 'action', 'run'),
+            interval=self.get_attr(element, 'interval'),
+            cron=self.get_attr(element, 'cron'),
+            at=self.get_attr(element, 'at'),
+            timezone=self.get_attr(element, 'timezone', 'UTC'),
+            retry=self.get_int_attr(element, 'retry', 3),
+            timeout=self.get_attr(element, 'timeout'),
+            overlap=self.get_bool_attr(element, 'overlap', False),
+            enabled=self.get_bool_attr(element, 'enabled', True)
+        )
+
+        # Parse body statements
+        for child in element:
+            statement = self.parse_statement(child)
+            if statement:
+                schedule_node.add_statement(statement)
+
+        return schedule_node

quantum/core/parsers/jobs/thread_parser.py

@@ -0,0 +1,57 @@
+"""
+Thread Parser - Parse q:thread statements
+
+Handles async thread configuration.
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser, ParserError
+from quantum.core.ast_nodes import ThreadNode
+
+
+class ThreadParser(BaseTagParser):
+    """
+    Parser for q:thread statements.
+
+    Supports:
+    - Thread execution
+    - Join/terminate actions
+    - Priority and callbacks
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['thread']
+
+    def parse(self, element: ET.Element) -> ThreadNode:
+        """
+        Parse q:thread statement.
+
+        Args:
+            element: XML element for q:thread
+
+        Returns:
+            ThreadNode AST node
+        """
+        name = self.get_attr(element, 'name')
+
+        if not name:
+            raise ParserError("Thread requires 'name' attribute")
+
+        thread_node = ThreadNode(
+            name=name,
+            action=self.get_attr(element, 'action', 'run'),
+            priority=self.get_attr(element, 'priority', 'normal'),
+            timeout=self.get_attr(element, 'timeout'),
+            on_complete=self.get_attr(element, 'onComplete'),
+            on_error=self.get_attr(element, 'onError')
+        )
+
+        # Parse body statements
+        for child in element:
+            statement = self.parse_statement(child)
+            if statement:
+                thread_node.add_statement(statement)
+
+        return thread_node

quantum/core/parsers/messaging/__init__.py

@@ -0,0 +1,17 @@
+"""
+Messaging Parsers
+
+Parsers for messaging operations: websocket, message, subscribe, queue, messageAck, messageNack.
+"""
+
+from .websocket_parser import WebSocketParser, WebSocketSendParser, WebSocketCloseParser
+from .message_parser import MessageParser, SubscribeParser
+from .queue_parser import QueueParser
+from .message_ack_parser import MessageAckParser
+from .message_nack_parser import MessageNackParser
+
+__all__ = [
+    'WebSocketParser', 'WebSocketSendParser', 'WebSocketCloseParser',
+    'MessageParser', 'SubscribeParser', 'QueueParser',
+    'MessageAckParser', 'MessageNackParser'
+]

quantum/core/parsers/messaging/message_ack_parser.py

@@ -0,0 +1,30 @@
+"""
+MessageAck Parser - Parse q:messageAck statements
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser
+from quantum.core.ast_nodes import MessageAckNode
+
+
+class MessageAckParser(BaseTagParser):
+    """
+    Parser for q:messageAck statements for acknowledging messages.
+
+    Example:
+        <q:subscribe name="worker" queue="tasks" ack="manual">
+            <q:onMessage>
+                <q:set name="processed" value="true" />
+                <q:messageAck />
+            </q:onMessage>
+        </q:subscribe>
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['messageAck']
+
+    def parse(self, element: ET.Element) -> MessageAckNode:
+        """Parse q:messageAck element"""
+        return MessageAckNode()

quantum/core/parsers/messaging/message_nack_parser.py

@@ -0,0 +1,30 @@
+"""
+MessageNack Parser - Parse q:messageNack statements
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser
+from quantum.core.ast_nodes import MessageNackNode
+
+
+class MessageNackParser(BaseTagParser):
+    """
+    Parser for q:messageNack statements for negative acknowledgment.
+
+    Examples:
+        <!-- Reject and requeue -->
+        <q:messageNack requeue="true" />
+
+        <!-- Reject without requeue (send to DLQ) -->
+        <q:messageNack requeue="false" />
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['messageNack']
+
+    def parse(self, element: ET.Element) -> MessageNackNode:
+        """Parse q:messageNack element"""
+        requeue = element.get('requeue', 'true').lower() == 'true'
+        return MessageNackNode(requeue=requeue)

quantum/core/parsers/messaging/message_parser.py

@@ -0,0 +1,114 @@
+"""
+Message Parser - Parse q:message and q:subscribe statements
+
+Handles message queue operations.
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser, ParserError
+from quantum.core.ast_nodes import MessageNode, SubscribeNode, MessageHeaderNode
+
+
+class MessageParser(BaseTagParser):
+    """
+    Parser for q:message statements.
+
+    Supports:
+    - Publish (topic)
+    - Send (queue)
+    - Request/reply
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['message']
+
+    def parse(self, element: ET.Element) -> MessageNode:
+        """
+        Parse q:message statement.
+
+        Args:
+            element: XML element for q:message
+
+        Returns:
+            MessageNode AST node
+        """
+        msg_node = MessageNode(
+            name=self.get_attr(element, 'name'),
+            topic=self.get_attr(element, 'topic'),
+            queue=self.get_attr(element, 'queue'),
+            type=self.get_attr(element, 'type', 'publish'),
+            timeout=self.get_attr(element, 'timeout')
+        )
+
+        # Parse children
+        for child in element:
+            child_type = self.get_element_name(child)
+
+            if child_type == 'header':
+                header = MessageHeaderNode(
+                    name=self.get_attr(child, 'name', ''),
+                    value=self.get_attr(child, 'value', '')
+                )
+                msg_node.add_header(header)
+            elif child_type == 'body':
+                msg_node.body = self.get_text(child)
+
+        return msg_node
+
+
+class SubscribeParser(BaseTagParser):
+    """
+    Parser for q:subscribe statements.
+
+    Supports:
+    - Topic subscription
+    - Queue consumption
+    - Message handlers
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['subscribe']
+
+    def parse(self, element: ET.Element) -> SubscribeNode:
+        """
+        Parse q:subscribe statement.
+
+        Args:
+            element: XML element for q:subscribe
+
+        Returns:
+            SubscribeNode AST node
+        """
+        name = self.get_attr(element, 'name')
+
+        if not name:
+            raise ParserError("Subscribe requires 'name' attribute")
+
+        sub_node = SubscribeNode(
+            name=name,
+            topic=self.get_attr(element, 'topic'),
+            topics=self.get_attr(element, 'topics'),
+            queue=self.get_attr(element, 'queue'),
+            ack=self.get_attr(element, 'ack', 'auto'),
+            prefetch=self.get_int_attr(element, 'prefetch', 1)
+        )
+
+        # Parse handlers
+        for child in element:
+            child_type = self.get_element_name(child)
+
+            if child_type == 'onMessage':
+                for handler_child in child:
+                    statement = self.parse_statement(handler_child)
+                    if statement:
+                        sub_node.add_on_message_statement(statement)
+            elif child_type == 'onError':
+                for handler_child in child:
+                    statement = self.parse_statement(handler_child)
+                    if statement:
+                        sub_node.add_on_error_statement(statement)
+
+        return sub_node

quantum/core/parsers/messaging/queue_parser.py

@@ -0,0 +1,61 @@
+"""
+Queue Parser - Parse q:queue statements
+
+Handles queue management operations.
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser, ParserError
+from quantum.core.ast_nodes import QueueNode
+
+
+class QueueParser(BaseTagParser):
+    """
+    Parser for q:queue statements.
+
+    Supports:
+    - Queue declaration
+    - Queue purge/delete
+    - Queue info
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['queue']
+
+    def parse(self, element: ET.Element) -> QueueNode:
+        """
+        Parse q:queue statement.
+
+        Args:
+            element: XML element for q:queue
+
+        Returns:
+            QueueNode AST node
+        """
+        name = self.get_attr(element, 'name')
+        action = self.get_attr(element, 'action', 'declare')
+
+        if not name:
+            raise ParserError("Queue requires 'name' attribute")
+
+        # Parse attributes matching legacy method
+        durable = self.get_bool_attr(element, 'durable', True)
+        exclusive = self.get_bool_attr(element, 'exclusive', False)
+        auto_delete = self.get_bool_attr(element, 'autoDelete', False)
+        dead_letter_queue = self.get_attr(element, 'deadLetterQueue')
+        ttl_str = self.get_attr(element, 'ttl')
+        ttl = int(ttl_str) if ttl_str else None
+        result = self.get_attr(element, 'result')
+
+        return QueueNode(
+            name=name,
+            action=action,
+            durable=durable,
+            exclusive=exclusive,
+            auto_delete=auto_delete,
+            dead_letter_queue=dead_letter_queue,
+            ttl=ttl,
+            result=result
+        )

quantum/core/parsers/messaging/websocket_parser.py

@@ -0,0 +1,121 @@
+"""
+WebSocket Parser - Parse q:websocket statements
+
+Handles WebSocket connection and messaging configuration.
+"""
+
+from typing import List
+from xml.etree import ElementTree as ET
+from quantum.core.parsers.base import BaseTagParser, ParserError
+from quantum.core.features.websocket.src.ast_node import (
+    WebSocketNode, WebSocketHandlerNode,
+    WebSocketSendNode, WebSocketCloseNode
+)
+
+
+class WebSocketParser(BaseTagParser):
+    """
+    Parser for q:websocket statements.
+
+    Supports:
+    - Connection configuration
+    - Event handlers
+    - Reconnection settings
+    """
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['websocket']
+
+    def parse(self, element: ET.Element) -> WebSocketNode:
+        """
+        Parse q:websocket statement.
+
+        Args:
+            element: XML element for q:websocket
+
+        Returns:
+            WebSocketNode AST node
+        """
+        name = self.get_attr(element, 'name')
+        url = self.get_attr(element, 'url')
+
+        if not name:
+            raise ParserError("WebSocket requires 'name' attribute")
+        if not url:
+            raise ParserError("WebSocket requires 'url' attribute")
+
+        ws_node = WebSocketNode(
+            name=name,
+            url=url,
+            auto_connect=self.get_bool_attr(element, 'autoConnect', True),
+            reconnect=self.get_bool_attr(element, 'reconnect', True),
+            reconnect_delay=self.get_int_attr(element, 'reconnectDelay', 1000),
+            max_reconnects=self.get_int_attr(element, 'maxReconnects', 10),
+            heartbeat=self.get_int_attr(element, 'heartbeat', 30000),
+            protocols=self.get_attr(element, 'protocols', '')
+        )
+
+        # Parse event handlers
+        for child in element:
+            child_type = self.get_element_name(child)
+
+            if child_type.startswith('on-'):
+                event = child_type[3:]  # Remove 'on-' prefix
+                handler = self._parse_handler(child, event)
+                ws_node.handlers.append(handler)
+
+        return ws_node
+
+    def _parse_handler(self, element: ET.Element, event: str) -> WebSocketHandlerNode:
+        """Parse event handler."""
+        handler = WebSocketHandlerNode(event=event)
+
+        for child in element:
+            statement = self.parse_statement(child)
+            if statement:
+                handler.body.append(statement)
+
+        return handler
+
+
+class WebSocketSendParser(BaseTagParser):
+    """Parser for q:websocket-send statements."""
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['websocket-send']
+
+    def parse(self, element: ET.Element) -> WebSocketSendNode:
+        connection = self.get_attr(element, 'connection')
+        message = self.get_attr(element, 'message')
+        msg_type = self.get_attr(element, 'type', 'text')
+
+        if not connection:
+            raise ParserError("websocket-send requires 'connection' attribute")
+
+        return WebSocketSendNode(
+            connection=connection,
+            message=message or '',
+            type=msg_type
+        )
+
+
+class WebSocketCloseParser(BaseTagParser):
+    """Parser for q:websocket-close statements."""
+
+    @property
+    def tag_names(self) -> List[str]:
+        return ['websocket-close']
+
+    def parse(self, element: ET.Element) -> WebSocketCloseNode:
+        connection = self.get_attr(element, 'connection')
+
+        if not connection:
+            raise ParserError("websocket-close requires 'connection' attribute")
+
+        return WebSocketCloseNode(
+            connection=connection,
+            code=self.get_int_attr(element, 'code', 1000),
+            reason=self.get_attr(element, 'reason', '')
+        )