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

exonware/xwnode/nodes/strategies/node_union_find.py

@@ -1,192 +0,0 @@
-"""
-Union-Find Node Strategy Implementation
-
-This module implements the UNION_FIND strategy for efficient set operations.
-"""
-
-from typing import Any, Iterator, Dict, List, Set
-from .base import ANodeGraphStrategy
-from .contracts import NodeType
-from ...defs import NodeMode, NodeTrait
-from ..utils import (
-    UnionFind,
-    safe_to_native_conversion,
-    create_basic_metrics,
-    create_basic_backend_info,
-    create_size_tracker,
-    create_access_tracker,
-    update_size_tracker,
-    record_access,
-    get_access_metrics
-)
-
-
-class UnionFindStrategy(ANodeGraphStrategy):
-    """
-    Union-Find node strategy for efficient set operations.
-    
-    Optimized for union, find, and connected oper
-    
-    # Strategy type classification
-    STRATEGY_TYPE = NodeType.GRAPH
-ations on disjoint sets.
-    """
-    
-    def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
-        """Initialize the union-find strategy."""
-        super().__init__(NodeMode.UNION_FIND, traits, **options)
-        self._union_find = UnionFind()
-        self._size_tracker = create_size_tracker()
-        self._access_tracker = create_access_tracker()
-    
-    def get_supported_traits(self) -> NodeTrait:
-        """Get the traits supported by the union-find strategy."""
-        return (NodeTrait.SET_OPERATIONS | NodeTrait.HIERARCHICAL)
-    
-    # ============================================================================
-    # CORE OPERATIONS
-    # ============================================================================
-    
-    def put(self, key: Any, value: Any = None) -> None:
-        """Store a key-value pair (creates a new set)."""
-        str_key = str(key)
-        if str_key not in self._union_find.parent:
-            update_size_tracker(self._size_tracker, 1)
-        self._union_find.make_set(str_key, value)
-        record_access(self._access_tracker, 'put_count')
-    
-    def get(self, key: Any, default: Any = None) -> Any:
-        """Retrieve a value by key."""
-        str_key = str(key)
-        record_access(self._access_tracker, 'get_count')
-        return self._union_find.values.get(str_key, default)
-    
-    def has(self, key: Any) -> bool:
-        """Check if key exists."""
-        return str(key) in self._union_find.parent
-    
-    def remove(self, key: Any) -> bool:
-        """Remove a key-value pair."""
-        str_key = str(key)
-        if str_key in self._union_find.parent:
-            # Remove from all data structures
-            del self._union_find.parent[str_key]
-            if str_key in self._union_find.rank:
-                del self._union_find.rank[str_key]
-            if str_key in self._union_find.values:
-                del self._union_find.values[str_key]
-            update_size_tracker(self._size_tracker, -1)
-            record_access(self._access_tracker, 'delete_count')
-            return True
-        return False
-    
-    def delete(self, key: Any) -> bool:
-        """Remove a key-value pair (alias for remove)."""
-        return self.remove(key)
-    
-    def clear(self) -> None:
-        """Clear all data."""
-        self._union_find = UnionFind()
-        self._size_tracker['size'] = 0
-    
-    def keys(self) -> Iterator[str]:
-        """Get all keys."""
-        return iter(self._union_find.parent.keys())
-    
-    def values(self) -> Iterator[Any]:
-        """Get all values."""
-        return iter(self._union_find.values.values())
-    
-    def items(self) -> Iterator[tuple[str, Any]]:
-        """Get all key-value pairs."""
-        return iter(self._union_find.values.items())
-    
-    def __len__(self) -> int:
-        """Get the number of items."""
-        return self._size_tracker['size']
-    
-    def to_native(self) -> Dict[str, Any]:
-        """Convert to native Python dict with set structure info."""
-        result = {}
-        for key in self._union_find.parent.keys():
-            result[key] = {
-                'value': safe_to_native_conversion(self._union_find.values.get(key)),
-                'root': self._union_find.find(key),
-                'set_id': self._union_find.find(key)
-            }
-        return result
-    
-    @property
-    def is_list(self) -> bool:
-        """This is not a list strategy."""
-        return False
-    
-    @property
-    def is_dict(self) -> bool:
-        """This behaves like a dict but with set semantics."""
-        return True
-    
-    # ============================================================================
-    # UNION-FIND SPECIFIC OPERATIONS
-    # ============================================================================
-    
-    def make_set(self, element: str, value: Any = None) -> None:
-        """Create a new set containing only the given element."""
-        if element not in self._union_find.parent:
-            update_size_tracker(self._size_tracker, 1)
-        self._union_find.make_set(element, value)
-    
-    def find(self, element: str) -> str:
-        """Find the root of the set containing element (with path compression)."""
-        return self._union_find.find(element)
-    
-    def union(self, element1: str, element2: str) -> bool:
-        """Union the sets containing element1 and element2."""
-        return self._union_find.union(element1, element2)
-    
-    def connected(self, element1: str, element2: str) -> bool:
-        """Check if two elements are in the same set."""
-        return self._union_find.connected(element1, element2)
-    
-    def get_set_members(self, element: str) -> Set[str]:
-        """Get all members of the set containing the given element."""
-        return self._union_find.get_set_members(element)
-    
-    def get_all_sets(self) -> List[Set[str]]:
-        """Get all disjoint sets."""
-        return self._union_find.get_all_sets()
-    
-    def get_set_count(self) -> int:
-        """Get the number of disjoint sets."""
-        return self._union_find.get_set_count()
-    
-    def get_set_size(self, element: str) -> int:
-        """Get the size of the set containing the given element."""
-        return self._union_find.get_set_size(element)
-    
-    # ============================================================================
-    # PERFORMANCE CHARACTERISTICS
-    # ============================================================================
-    
-    def backend_info(self) -> Dict[str, Any]:
-        """Get backend implementation info."""
-        return create_basic_backend_info(
-            'UNION_FIND',
-            'UnionFind with path compression and union by rank',
-            complexity={
-                'find': 'O(α(n)) amortized where α is inverse Ackermann',
-                'union': 'O(α(n)) amortized where α is inverse Ackermann',
-                'connected': 'O(α(n)) amortized where α is inverse Ackermann'
-            }
-        )
-    
-    def metrics(self) -> Dict[str, Any]:
-        """Get performance metrics."""
-        base_metrics = create_basic_metrics('UNION_FIND', self._size_tracker['size'])
-        access_metrics = get_access_metrics(self._access_tracker)
-        base_metrics.update(access_metrics)
-        base_metrics.update({
-            'set_count': self._union_find.get_set_count(),
-            'avg_set_size': self._size_tracker['size'] / max(1, self._union_find.get_set_count())
-        })
-        return base_metrics

exonware/xwnode/queries/executors/__init__.py

@@ -1,47 +0,0 @@
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/__init__.py
-
-Query Operation Executors
-
-This package implements the execution layer for 50 XWQuery Script operations.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from .contracts import (
-    IOperationExecutor,
-    Action,
-    ExecutionContext,
-    ExecutionResult
-)
-from .defs import OperationCapability, OperationType, ExecutionStatus
-from .errors import ExecutorError, OperationExecutionError, ValidationError, UnsupportedOperationError
-from .base import AOperationExecutor
-from .registry import OperationRegistry, get_operation_registry, register_operation
-
-__all__ = [
-    # Contracts
-    'IOperationExecutor',
-    'Action',
-    'ExecutionContext',
-    'ExecutionResult',
-    # Types
-    'OperationCapability',
-    'OperationType',
-    'ExecutionStatus',
-    # Errors
-    'ExecutorError',
-    'OperationExecutionError',
-    'ValidationError',
-    'UnsupportedOperationError',
-    # Base
-    'AOperationExecutor',
-    # Registry
-    'OperationRegistry',
-    'get_operation_registry',
-    'register_operation',
-]

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

@@ -1,37 +0,0 @@
-"""Advanced operation executors."""
-
-from .join_executor import JoinExecutor
-from .union_executor import UnionExecutor
-from .with_cte_executor import WithCteExecutor
-from .aggregate_executor import AggregateExecutor
-from .foreach_executor import ForeachExecutor
-from .let_executor import LetExecutor
-from .for_loop_executor import ForLoopExecutor
-from .window_executor import WindowExecutor
-from .describe_executor import DescribeExecutor
-from .construct_executor import ConstructExecutor
-from .ask_executor import AskExecutor
-from .subscribe_executor import SubscribeExecutor
-from .subscription_executor import SubscriptionExecutor
-from .mutation_executor import MutationExecutor
-from .pipe_executor import PipeExecutor
-from .options_executor import OptionsExecutor
-
-__all__ = [
-    'JoinExecutor',
-    'UnionExecutor',
-    'WithCteExecutor',
-    'AggregateExecutor',
-    'ForeachExecutor',
-    'LetExecutor',
-    'ForLoopExecutor',
-    'WindowExecutor',
-    'DescribeExecutor',
-    'ConstructExecutor',
-    'AskExecutor',
-    'SubscribeExecutor',
-    'SubscriptionExecutor',
-    'MutationExecutor',
-    'PipeExecutor',
-    'OptionsExecutor',
-]

exonware/xwnode/queries/executors/advanced/aggregate_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/aggregate_executor.py
-
-AGGREGATE Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 AggregateExecutor(AUniversalOperationExecutor):
-    """
-    AGGREGATE operation executor.
-    
-    Window aggregation operations
-    
-    Capability: Universal
-    Operation Type: AGGREGATION
-    """
-    
-    OPERATION_NAME = "AGGREGATE"
-    OPERATION_TYPE = OperationType.AGGREGATION
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute AGGREGATE operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_aggregate(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_aggregate(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute aggregate logic."""
-        # Implementation here
-        return {'result': 'AGGREGATE executed', 'params': params}

exonware/xwnode/queries/executors/advanced/ask_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/ask_executor.py
-
-ASK Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 AskExecutor(AUniversalOperationExecutor):
-    """
-    ASK operation executor.
-    
-    Boolean query (yes/no result)
-    
-    Capability: Universal
-    Operation Type: ADVANCED
-    """
-    
-    OPERATION_NAME = "ASK"
-    OPERATION_TYPE = OperationType.ADVANCED
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute ASK operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_ask(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_ask(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute ask logic."""
-        # Implementation here
-        return {'result': 'ASK executed', 'params': params}

exonware/xwnode/queries/executors/advanced/construct_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/construct_executor.py
-
-CONSTRUCT Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 ConstructExecutor(AUniversalOperationExecutor):
-    """
-    CONSTRUCT operation executor.
-    
-    Constructs new data structures
-    
-    Capability: Universal
-    Operation Type: ADVANCED
-    """
-    
-    OPERATION_NAME = "CONSTRUCT"
-    OPERATION_TYPE = OperationType.ADVANCED
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute CONSTRUCT operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_construct(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_construct(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute construct logic."""
-        # Implementation here
-        return {'result': 'CONSTRUCT executed', 'params': params}

exonware/xwnode/queries/executors/advanced/describe_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/describe_executor.py
-
-DESCRIBE Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 DescribeExecutor(AUniversalOperationExecutor):
-    """
-    DESCRIBE operation executor.
-    
-    Describes structure/schema
-    
-    Capability: Universal
-    Operation Type: ADVANCED
-    """
-    
-    OPERATION_NAME = "DESCRIBE"
-    OPERATION_TYPE = OperationType.ADVANCED
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute DESCRIBE operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_describe(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_describe(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute describe logic."""
-        # Implementation here
-        return {'result': 'DESCRIBE executed', 'params': params}

exonware/xwnode/queries/executors/advanced/for_loop_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/for_loop_executor.py
-
-FOR Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 ForLoopExecutor(AUniversalOperationExecutor):
-    """
-    FOR operation executor.
-    
-    For loop construct
-    
-    Capability: Universal
-    Operation Type: CONTROL_FLOW
-    """
-    
-    OPERATION_NAME = "FOR"
-    OPERATION_TYPE = OperationType.CONTROL_FLOW
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute FOR operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_for_loop(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_for_loop(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute for_loop logic."""
-        # Implementation here
-        return {'result': 'FOR executed', 'params': params}

exonware/xwnode/queries/executors/advanced/foreach_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/foreach_executor.py
-
-FOREACH Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 ForeachExecutor(AUniversalOperationExecutor):
-    """
-    FOREACH operation executor.
-    
-    Iterates over collections
-    
-    Capability: Universal
-    Operation Type: CONTROL_FLOW
-    """
-    
-    OPERATION_NAME = "FOREACH"
-    OPERATION_TYPE = OperationType.CONTROL_FLOW
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute FOREACH operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_foreach(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_foreach(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute foreach logic."""
-        # Implementation here
-        return {'result': 'FOREACH executed', 'params': params}

exonware/xwnode/queries/executors/advanced/join_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/join_executor.py
-
-JOIN Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 JoinExecutor(AUniversalOperationExecutor):
-    """
-    JOIN operation executor.
-    
-    Joins data from multiple sources
-    
-    Capability: Universal
-    Operation Type: JOINING
-    """
-    
-    OPERATION_NAME = "JOIN"
-    OPERATION_TYPE = OperationType.JOINING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute JOIN operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_join(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_join(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute join logic."""
-        # Implementation here
-        return {'result': 'JOIN executed', 'params': params}

exonware/xwnode/queries/executors/advanced/let_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/let_executor.py
-
-LET Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 LetExecutor(AUniversalOperationExecutor):
-    """
-    LET operation executor.
-    
-    Variable binding/assignment
-    
-    Capability: Universal
-    Operation Type: CONTROL_FLOW
-    """
-    
-    OPERATION_NAME = "LET"
-    OPERATION_TYPE = OperationType.CONTROL_FLOW
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute LET operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_let(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_let(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute let logic."""
-        # Implementation here
-        return {'result': 'LET executed', 'params': params}