exonware-xwnode 0.0.1.22__py3-none-any.whl → 0.0.1.23__py3-none-any.whl

exonware/xwnode/queries/executors/ordering/order_executor.py

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/ordering/order_executor.py
-
-ORDER Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-from ...nodes.strategies.contracts import NodeType
-
-class OrderExecutor(AOperationExecutor):
-    """
-    ORDER operation executor.
-    
-    Orders/sorts data
-    
-    Capability: TREE, LINEAR only
-    Operation Type: ORDERING
-    """
-    
-    OPERATION_NAME = "ORDER"
-    OPERATION_TYPE = OperationType.ORDERING
-    SUPPORTED_NODE_TYPES = [NodeType.TREE, NodeType.LINEAR]
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute ORDER operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_order(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_order(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute order logic."""
-        # Implementation here
-        return {'result': 'ORDER executed', 'params': params}

exonware/xwnode/queries/executors/projection/__init__.py

@@ -1,9 +0,0 @@
-"""Projection operation executors."""
-
-from .project_executor import ProjectExecutor
-from .extend_executor import ExtendExecutor
-
-__all__ = [
-    'ProjectExecutor',
-    'ExtendExecutor',
-]

exonware/xwnode/queries/executors/projection/extend_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/projection/extend_executor.py
-
-EXTEND Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-class ExtendExecutor(AUniversalOperationExecutor):
-    """
-    EXTEND operation executor.
-    
-    Extends data with computed fields
-    
-    Capability: Universal
-    Operation Type: PROJECTION
-    """
-    
-    OPERATION_NAME = "EXTEND"
-    OPERATION_TYPE = OperationType.PROJECTION
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute EXTEND operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_extend(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_extend(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute extend logic."""
-        # Implementation here
-        return {'result': 'EXTEND executed', 'params': params}

exonware/xwnode/queries/executors/projection/project_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/projection/project_executor.py
-
-PROJECT Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-class ProjectExecutor(AUniversalOperationExecutor):
-    """
-    PROJECT operation executor.
-    
-    Projects/selects specific fields
-    
-    Capability: Universal
-    Operation Type: PROJECTION
-    """
-    
-    OPERATION_NAME = "PROJECT"
-    OPERATION_TYPE = OperationType.PROJECTION
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute PROJECT operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_project(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_project(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute project logic."""
-        # Implementation here
-        return {'result': 'PROJECT executed', 'params': params}

exonware/xwnode/queries/executors/registry.py

@@ -1,173 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/registry.py
-
-Operation Executor Registry
-
-This module provides registry for managing operation executors.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 08-Oct-2025
-"""
-
-import threading
-from typing import Dict, Type, Optional, List
-
-from .contracts import IOperationExecutor, NodeType
-from ...errors import XWNodeValueError
-
-
-class OperationRegistry:
-    """
-    Registry for operation executors.
-    
-    Manages registration and retrieval of executors for the 50 XWQuery operations.
-    Thread-safe implementation with singleton pattern.
-    """
-    
-    _instance = None
-    _lock = threading.Lock()
-    
-    def __new__(cls):
-        """Ensure singleton instance."""
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._initialized = False
-        return cls._instance
-    
-    def __init__(self):
-        """Initialize the registry."""
-        if self._initialized:
-            return
-        
-        self._executors: Dict[str, Type[IOperationExecutor]] = {}
-        self._instances: Dict[str, IOperationExecutor] = {}
-        self._lock = threading.RLock()
-        self._initialized = True
-    
-    def register(self, operation_name: str, executor_class: Type[IOperationExecutor]) -> None:
-        """
-        Register an executor for an operation.
-        
-        Args:
-            operation_name: Name of operation (e.g., "SELECT")
-            executor_class: Executor class
-        """
-        with self._lock:
-            self._executors[operation_name.upper()] = executor_class
-    
-    def get(self, operation_name: str) -> Optional[IOperationExecutor]:
-        """
-        Get executor instance for an operation.
-        
-        Args:
-            operation_name: Name of operation
-            
-        Returns:
-            Executor instance or None if not found
-        """
-        operation_name = operation_name.upper()
-        
-        with self._lock:
-            # Return cached instance if exists
-            if operation_name in self._instances:
-                return self._instances[operation_name]
-            
-            # Create new instance
-            if operation_name in self._executors:
-                executor_class = self._executors[operation_name]
-                instance = executor_class()
-                self._instances[operation_name] = instance
-                return instance
-        
-        return None
-    
-    def has(self, operation_name: str) -> bool:
-        """
-        Check if operation is registered.
-        
-        Args:
-            operation_name: Name of operation
-            
-        Returns:
-            True if operation is registered
-        """
-        return operation_name.upper() in self._executors
-    
-    def list_operations(self) -> List[str]:
-        """Get list of all registered operations."""
-        with self._lock:
-            return list(self._executors.keys())
-    
-    def list_operations_for_node_type(self, node_type: NodeType) -> List[str]:
-        """
-        Get list of operations supported by a node type.
-        
-        Args:
-            node_type: Node type to check
-            
-        Returns:
-            List of operation names
-        """
-        operations = []
-        
-        with self._lock:
-            for op_name, executor_class in self._executors.items():
-                # Instantiate temporarily to check
-                executor = executor_class()
-                if executor.can_execute_on(node_type):
-                    operations.append(op_name)
-        
-        return operations
-    
-    def clear(self) -> None:
-        """Clear all registrations (for testing)."""
-        with self._lock:
-            self._executors.clear()
-            self._instances.clear()
-
-
-# Global registry instance
-_global_registry: Optional[OperationRegistry] = None
-_global_lock = threading.Lock()
-
-
-def get_operation_registry() -> OperationRegistry:
-    """Get the global operation registry instance."""
-    global _global_registry
-    
-    if _global_registry is None:
-        with _global_lock:
-            if _global_registry is None:
-                _global_registry = OperationRegistry()
-    
-    return _global_registry
-
-
-def register_operation(operation_name: str):
-    """
-    Decorator to register an operation executor.
-    
-    Usage:
-        @register_operation("CUSTOM_OP")
-        class CustomOperationExecutor(AOperationExecutor):
-            ...
-    """
-    def decorator(executor_class: Type[IOperationExecutor]):
-        registry = get_operation_registry()
-        registry.register(operation_name, executor_class)
-        return executor_class
-    return decorator
-
-
-__all__ = [
-    'OperationRegistry',
-    'get_operation_registry',
-    'register_operation',
-    'UnsupportedOperationError',
-]

exonware/xwnode/queries/parsers/__init__.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/parsers/__init__.py
-
-Query Parsers Module
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-from .contracts import IParamExtractor
-from .errors import ParserError, ParseError
-from .base import AParamExtractor
-from .sql_param_extractor import SQLParamExtractor
-
-__all__ = [
-    'IParamExtractor',
-    'ParserError',
-    'ParseError',
-    'AParamExtractor',
-    'SQLParamExtractor',
-]
-

exonware/xwnode/queries/parsers/base.py

@@ -1,86 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/parsers/base.py
-
-Parser Base Classes
-
-Abstract base class for parameter extractors.
-Follows DEV_GUIDELINES.md: base.py extends contracts.py interfaces.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-from abc import ABC
-from typing import Dict, Any, Union
-
-from .contracts import IParamExtractor
-from .errors import ParseError
-
-
-class AParamExtractor(IParamExtractor, ABC):
-    """
-    Abstract base class for parameter extractors.
-    
-    Extends IParamExtractor interface per DEV_GUIDELINES.md.
-    """
-    
-    def _parse_value(self, value_str: str) -> Union[str, int, float, bool, None]:
-        """
-        Parse value from string to appropriate type.
-        
-        Args:
-            value_str: String representation of value
-        
-        Returns:
-            Parsed value with correct type
-        """
-        value_str = value_str.strip().strip('"').strip("'")
-        
-        # Try boolean
-        if value_str.lower() == 'true':
-            return True
-        if value_str.lower() == 'false':
-            return False
-        if value_str.lower() == 'null' or value_str.lower() == 'none':
-            return None
-        
-        # Try number
-        try:
-            if '.' in value_str:
-                return float(value_str)
-            return int(value_str)
-        except ValueError:
-            pass
-        
-        # Return as string
-        return value_str
-    
-    def _split_fields(self, fields_str: str) -> list:
-        """Split comma-separated fields, handling nested expressions."""
-        if fields_str.strip() == '*':
-            return ['*']
-        
-        fields = []
-        current = []
-        paren_depth = 0
-        
-        for char in fields_str:
-            if char == '(':
-                paren_depth += 1
-            elif char == ')':
-                paren_depth -= 1
-            elif char == ',' and paren_depth == 0:
-                fields.append(''.join(current).strip())
-                current = []
-                continue
-            current.append(char)
-        
-        if current:
-            fields.append(''.join(current).strip())
-        
-        return fields
-

exonware/xwnode/queries/parsers/contracts.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/parsers/contracts.py
-
-Parser Contracts
-
-Interfaces for query parameter extractors.
-Follows DEV_GUIDELINES.md: contracts.py for all interfaces.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-from abc import ABC, abstractmethod
-from typing import Dict, Any
-
-
-class IParamExtractor(ABC):
-    """
-    Interface for parameter extractors.
-    
-    Extracts structured parameters from query strings.
-    """
-    
-    @abstractmethod
-    def extract_params(self, query: str, action_type: str) -> Dict[str, Any]:
-        """
-        Extract structured parameters from query.
-        
-        Args:
-            query: Raw query string
-            action_type: Type of action (SELECT, INSERT, etc.)
-        
-        Returns:
-            Structured parameters dictionary
-        """
-        pass
-    
-    @abstractmethod
-    def can_parse(self, query: str) -> bool:
-        """Check if this extractor can parse the query."""
-        pass
-

exonware/xwnode/queries/parsers/errors.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/parsers/errors.py
-
-Parser Errors
-
-Module-specific errors for query parsers.
-Extends root error classes per DEV_GUIDELINES.md - no redundancy.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.22
-Generation Date: 09-Oct-2025
-"""
-
-# Import and REUSE root error classes per DEV_GUIDELINES
-from ...errors import XWNodeError, XWNodeValueError
-
-
-class ParserError(XWNodeError):
-    """
-    Base error for parser operations.
-    
-    Extends XWNodeError from root - follows DEV_GUIDELINES principle.
-    """
-    pass
-
-
-class ParseError(ParserError):
-    """Raised when query parsing fails."""
-    
-    def __init__(self, query: str, reason: str, position: int = None):
-        message = f"Failed to parse query: {reason}"
-        if position is not None:
-            message += f" at position {position}"
-        super().__init__(message)
-        self.query = query
-        self.reason = reason
-        self.position = position
-
-
-class UnsupportedSyntaxError(ParserError):
-    """Raised when syntax is not supported."""
-    pass
-
-
-__all__ = [
-    'ParserError',
-    'ParseError',
-    'UnsupportedSyntaxError',
-]
-