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

exonware/xwnode/queries/executors/core/insert_executor.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/core/insert_executor.py
-
-INSERT Operation Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-
-
-class InsertExecutor(AUniversalOperationExecutor):
-    """INSERT operation executor - Universal operation."""
-    
-    OPERATION_NAME = "INSERT"
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute INSERT operation on node."""
-        key = action.params.get('key')
-        value = action.params.get('value')
-        
-        # Insert into node using strategy
-        if hasattr(context.node, 'insert'):
-            context.node.insert(key, value)
-        elif hasattr(context.node, 'put'):
-            context.node.put(key, value)
-        elif hasattr(context.node, '_strategy'):
-            context.node._strategy.insert(key, value)
-        
-        return ExecutionResult(data={'inserted': key}, affected_count=1)
-
-
-__all__ = ['InsertExecutor']

exonware/xwnode/queries/executors/core/select_executor.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/core/select_executor.py
-
-SELECT Operation Executor
-
-Implements SELECT operation execution on all node types.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, List, Dict, Optional
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationCapability
-from ...nodes.strategies.contracts import NodeType
-
-
-class SelectExecutor(AUniversalOperationExecutor):
-    """
-    SELECT operation executor - Universal operation.
-    
-    Works on all node types (LINEAR, TREE, GRAPH, MATRIX).
-    Retrieves and projects data from nodes.
-    """
-    
-    OPERATION_NAME = "SELECT"
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """
-        Execute SELECT operation.
-        
-        Supports:
-        - Column projection
-        - Star (*) selection
-        - Expressions and aliases
-        - Adapts to different node types
-        """
-        # Extract parameters
-        columns = action.params.get('columns', ['*'])
-        source = action.params.get('from', context.node)
-        
-        # Get node type
-        node_type = self._get_node_type(context.node)
-        
-        # Route to appropriate handler based on node type
-        if node_type == NodeType.LINEAR:
-            data = self._select_from_linear(source, columns, context)
-        elif node_type == NodeType.TREE:
-            data = self._select_from_tree(source, columns, context)
-        elif node_type == NodeType.GRAPH:
-            data = self._select_from_graph(source, columns, context)
-        elif node_type == NodeType.MATRIX:
-            data = self._select_from_matrix(source, columns, context)
-        else:  # HYBRID
-            data = self._select_from_tree(source, columns, context)  # Default to tree
-        
-        return ExecutionResult(
-            data=data,
-            affected_count=len(data) if isinstance(data, list) else 1
-        )
-    
-    def _get_node_type(self, node: Any) -> NodeType:
-        """Get node's strategy type."""
-        if hasattr(node, '_strategy') and hasattr(node._strategy, 'STRATEGY_TYPE'):
-            return node._strategy.STRATEGY_TYPE
-        elif hasattr(node, 'STRATEGY_TYPE'):
-            return node.STRATEGY_TYPE
-        return NodeType.TREE  # Default
-    
-    def _select_from_linear(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
-        """Select from linear node (list-like)."""
-        results = []
-        
-        # Iterate through linear structure
-        if hasattr(source, 'items'):
-            for key, value in source.items():
-                if columns == ['*']:
-                    results.append({'key': key, 'value': value})
-                else:
-                    row = self._project_columns(value, columns)
-                    results.append(row)
-        
-        return results
-    
-    def _select_from_tree(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
-        """Select from tree node (key-value map)."""
-        results = []
-        
-        # Iterate through tree structure
-        if hasattr(source, 'items'):
-            for key, value in source.items():
-                if columns == ['*']:
-                    results.append({'key': key, 'value': value})
-                else:
-                    row = self._project_columns(value, columns)
-                    if row:
-                        results.append(row)
-        
-        return results
-    
-    def _select_from_graph(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
-        """Select from graph node."""
-        # For graphs, return nodes
-        results = []
-        
-        if hasattr(source, 'items'):
-            for key, value in source.items():
-                if columns == ['*']:
-                    results.append({'node_id': key, 'node_data': value})
-                else:
-                    row = self._project_columns(value, columns)
-                    if row:
-                        row['node_id'] = key
-                        results.append(row)
-        
-        return results
-    
-    def _select_from_matrix(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
-        """Select from matrix node."""
-        results = []
-        
-        # Iterate through matrix
-        if hasattr(source, 'items'):
-            for key, value in source.items():
-                if columns == ['*']:
-                    results.append({'position': key, 'value': value})
-                else:
-                    row = self._project_columns(value, columns)
-                    if row:
-                        results.append(row)
-        
-        return results
-    
-    def _project_columns(self, value: Any, columns: List[str]) -> Optional[Dict]:
-        """Project specific columns from a value."""
-        if not isinstance(value, dict):
-            return {'value': value}
-        
-        projected = {}
-        for col in columns:
-            if col in value:
-                projected[col] = value[col]
-        
-        return projected if projected else None
-
-
-__all__ = ['SelectExecutor']

exonware/xwnode/queries/executors/core/update_executor.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/core/update_executor.py
-
-UPDATE Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-from ...nodes.strategies.contracts import NodeType
-
-
-class UpdateExecutor(AUniversalOperationExecutor):
-    """
-    UPDATE operation executor - Universal operation.
-    
-    Updates existing data in nodes based on specified conditions.
-    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
-    
-    Capability: Universal
-    Operation Type: CORE
-    """
-    
-    OPERATION_NAME = "UPDATE"
-    OPERATION_TYPE = OperationType.CORE
-    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute UPDATE operation."""
-        # 1. Extract parameters
-        params = action.params
-        target = params.get('target', None)  # What to update (path/key)
-        values = params.get('values', {})    # New values
-        condition = params.get('where', None)  # Update condition
-        
-        # 2. Get node strategy
-        node = context.node
-        
-        # 3. Execute update
-        result_data = self._execute_update(node, target, values, condition, context)
-        
-        # 4. Return result
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={
-                'updated_count': result_data.get('count', 0),
-                'target': target,
-                'condition': condition
-            }
-        )
-    
-    def _execute_update(self, node: Any, target: str, values: Dict, 
-                       condition: Any, context: ExecutionContext) -> Dict:
-        """Actual UPDATE logic."""
-        updated_count = 0
-        updated_items = []
-        
-        if target:
-            # Update specific target
-            try:
-                current = node.get(target, default=None)
-                if current is not None and self._matches_condition(current, condition):
-                    node.set(target, values)
-                    updated_count = 1
-                    updated_items.append(target)
-            except Exception as e:
-                return {
-                    'count': 0,
-                    'items': [],
-                    'error': str(e)
-                }
-        else:
-            # Update all matching items
-            # This is a simplified implementation - real version would traverse node
-            updated_count = 0
-            updated_items = []
-        
-        return {
-            'count': updated_count,
-            'items': updated_items,
-            'values': values
-        }
-    
-    def _matches_condition(self, item: Any, condition: Any) -> bool:
-        """Check if item matches condition."""
-        if condition is None:
-            return True
-        
-        # Simplified condition checking
-        # Real implementation would evaluate WHERE clause
-        return True
-

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

@@ -1,13 +0,0 @@
-"""Data operation executors."""
-
-from .load_executor import LoadExecutor
-from .store_executor import StoreExecutor
-from .merge_executor import MergeExecutor
-from .alter_executor import AlterExecutor
-
-__all__ = [
-    'LoadExecutor',
-    'StoreExecutor',
-    'MergeExecutor',
-    'AlterExecutor',
-]

exonware/xwnode/queries/executors/data/alter_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/data/alter_executor.py
-
-ALTER 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 AlterExecutor(AUniversalOperationExecutor):
-    """
-    ALTER operation executor.
-    
-    Alters structure/schema
-    
-    Capability: Universal
-    Operation Type: DATA_OPS
-    """
-    
-    OPERATION_NAME = "ALTER"
-    OPERATION_TYPE = OperationType.DATA_OPS
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute ALTER operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_alter(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_alter(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute alter logic."""
-        # Implementation here
-        return {'result': 'ALTER executed', 'params': params}

exonware/xwnode/queries/executors/data/load_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/data/load_executor.py
-
-LOAD 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 LoadExecutor(AUniversalOperationExecutor):
-    """
-    LOAD operation executor.
-    
-    Loads data from external sources
-    
-    Capability: Universal
-    Operation Type: DATA_OPS
-    """
-    
-    OPERATION_NAME = "LOAD"
-    OPERATION_TYPE = OperationType.DATA_OPS
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute LOAD operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_load(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_load(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute load logic."""
-        # Implementation here
-        return {'result': 'LOAD executed', 'params': params}

exonware/xwnode/queries/executors/data/merge_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/data/merge_executor.py
-
-MERGE 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 MergeExecutor(AUniversalOperationExecutor):
-    """
-    MERGE operation executor.
-    
-    Merges/upserts data
-    
-    Capability: Universal
-    Operation Type: DATA_OPS
-    """
-    
-    OPERATION_NAME = "MERGE"
-    OPERATION_TYPE = OperationType.DATA_OPS
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute MERGE operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_merge(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_merge(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute merge logic."""
-        # Implementation here
-        return {'result': 'MERGE executed', 'params': params}

exonware/xwnode/queries/executors/data/store_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/data/store_executor.py
-
-STORE 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 StoreExecutor(AUniversalOperationExecutor):
-    """
-    STORE operation executor.
-    
-    Stores data to external destinations
-    
-    Capability: Universal
-    Operation Type: DATA_OPS
-    """
-    
-    OPERATION_NAME = "STORE"
-    OPERATION_TYPE = OperationType.DATA_OPS
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute STORE operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_store(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_store(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute store logic."""
-        # Implementation here
-        return {'result': 'STORE executed', 'params': params}

exonware/xwnode/queries/executors/defs.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/defs.py
-
-Executor Types and Enums
-
-Module-specific types for query operation executors.
-Imports shared types from root defs.py per DEV_GUIDELINES.md.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from enum import Enum, Flag, auto
-
-# Import shared types from root
-from ...defs import QueryMode, QueryTrait
-
-# Import node type from nodes module
-from ...nodes.strategies.contracts import NodeType
-
-
-class OperationType(Enum):
-    """
-    Operation category classification.
-    
-    Used to group the 50 operations by their primary purpose.
-    """
-    CORE = auto()           # SELECT, INSERT, UPDATE, DELETE, CREATE, DROP
-    FILTERING = auto()      # WHERE, FILTER, BETWEEN, LIKE, IN, HAS
-    AGGREGATION = auto()    # GROUP BY, HAVING, SUM, AVG, COUNT, MIN, MAX, DISTINCT
-    ORDERING = auto()       # ORDER BY, LIMIT, OFFSET
-    JOINING = auto()        # JOIN, UNION, WITH, OPTIONAL
-    GRAPH = auto()          # MATCH, PATH, OUT, IN_TRAVERSE, RETURN
-    PROJECTION = auto()     # PROJECT, EXTEND, CONSTRUCT
-    SEARCH = auto()         # TERM, RANGE
-    DATA_OPS = auto()       # LOAD, STORE, MERGE, ALTER, DESCRIBE
-    CONTROL_FLOW = auto()   # FOREACH, LET, FOR
-    WINDOW = auto()         # WINDOW, AGGREGATE
-    ARRAY = auto()          # SLICING, INDEXING
-    ADVANCED = auto()       # ASK, SUBSCRIBE, MUTATION, PIPE, OPTIONS, VALUES
-
-
-class ExecutionStatus(Enum):
-    """
-    Execution status for operations.
-    """
-    PENDING = auto()        # Not yet started
-    VALIDATING = auto()     # Validating action
-    EXECUTING = auto()      # Currently executing
-    COMPLETED = auto()      # Successfully completed
-    FAILED = auto()         # Execution failed
-    CANCELLED = auto()      # Execution cancelled
-
-
-class OperationCapability(Flag):
-    """
-    Operation capability flags.
-    
-    Defines what capabilities an operation requires to execute.
-    Moved from contracts.py per DEV_GUIDELINES.md (enums in types.py).
-    """
-    NONE = 0
-    
-    # Node type requirements
-    REQUIRES_LINEAR = auto()
-    REQUIRES_TREE = auto()
-    REQUIRES_GRAPH = auto()
-    REQUIRES_MATRIX = auto()
-    
-    # Trait requirements
-    REQUIRES_ORDERED = auto()
-    REQUIRES_INDEXED = auto()
-    REQUIRES_HIERARCHICAL = auto()
-    REQUIRES_WEIGHTED = auto()
-    REQUIRES_SPATIAL = auto()
-    
-    # Special requirements
-    REQUIRES_MUTABLE = auto()
-    REQUIRES_TRANSACTIONAL = auto()
-
-
-__all__ = [
-    'OperationType',
-    'ExecutionStatus',
-    'OperationCapability',
-    'NodeType',  # Re-export for convenience
-    'QueryMode',  # Re-export from root
-    'QueryTrait',  # Re-export from root
-]