exonware-xwnode 0.0.1.12__py3-none-any.whl

exonware/xwnode/strategies/queries/elastic_dsl.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Elasticsearch DSL Query Strategy
+
+This module implements the Elasticsearch DSL query strategy for Elasticsearch Query DSL operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+from typing import Any, Dict, List, Optional
+from .base import AStructuredQueryStrategy
+from ...errors import XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class ElasticDSLStrategy(AStructuredQueryStrategy):
+    """Elasticsearch DSL query strategy for Elasticsearch Query DSL operations."""
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.ELASTIC_DSL
+        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.SEARCH
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute Elasticsearch DSL query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid Elasticsearch DSL query: {query}")
+        return {"result": "Elasticsearch DSL query executed", "query": query}
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate Elasticsearch DSL query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        return any(op in query for op in ["query", "match", "term", "bool", "filter", "must", "should"])
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get Elasticsearch DSL query execution plan."""
+        return {
+            "query_type": "ELASTIC_DSL",
+            "complexity": "HIGH",
+            "estimated_cost": 120
+        }
+    
+    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
+        """Execute SELECT query."""
+        return self.execute(f"GET /{table}/_search")
+    
+    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
+        """Execute INSERT query."""
+        return self.execute(f"POST /{table}/_doc")
+    
+    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
+        """Execute UPDATE query."""
+        return self.execute(f"POST /{table}/_update_by_query")
+    
+    def delete_query(self, table: str, where_clause: str = None) -> Any:
+        """Execute DELETE query."""
+        return self.execute(f"POST /{table}/_delete_by_query")
+    
+    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
+        """Execute JOIN query."""
+        return self.execute(f"GET /{tables[0]}/_search")
+    
+    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
+        """Execute aggregate query."""
+        return self.execute(f"GET /{table}/_search")

exonware/xwnode/strategies/queries/eql.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+EQL Query Strategy
+
+This module implements the EQL query strategy for Elasticsearch Query Language operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+from typing import Any, Dict, List, Optional
+from .base import AStructuredQueryStrategy
+from ...errors import XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class EQLStrategy(AStructuredQueryStrategy):
+    """EQL query strategy for Elasticsearch Query Language operations."""
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.EQL
+        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute EQL query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid EQL query: {query}")
+        return {"result": "EQL query executed", "query": query}
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate EQL query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        return any(op in query.upper() for op in ["SEQUENCE", "JOIN", "FILTER", "WHERE"])
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get EQL query execution plan."""
+        return {
+            "query_type": "EQL",
+            "complexity": "MEDIUM",
+            "estimated_cost": 100
+        }
+    
+    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
+        """Execute SELECT query."""
+        return self.execute(f"SELECT {', '.join(columns)} FROM {table}")
+    
+    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
+        """Execute INSERT query."""
+        return self.execute(f"INSERT INTO {table} VALUES {data}")
+    
+    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
+        """Execute UPDATE query."""
+        return self.execute(f"UPDATE {table} SET {data}")
+    
+    def delete_query(self, table: str, where_clause: str = None) -> Any:
+        """Execute DELETE query."""
+        return self.execute(f"DELETE FROM {table}")
+    
+    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
+        """Execute JOIN query."""
+        return self.execute(f"JOIN {tables[0]} WITH {tables[1]}")
+    
+    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
+        """Execute aggregate query."""
+        return self.execute(f"AGGREGATE {', '.join(functions)} FROM {table}")

exonware/xwnode/strategies/queries/flux.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Flux Query Strategy
+
+This module implements the Flux query strategy for InfluxDB Flux operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+from typing import Any, Dict, List, Optional
+from .base import AStructuredQueryStrategy
+from ...errors import XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class FluxStrategy(AStructuredQueryStrategy):
+    """Flux query strategy for InfluxDB Flux operations."""
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.FLUX
+        self._traits = QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL | QueryTrait.BATCH
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute Flux query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid Flux query: {query}")
+        return {"result": "Flux query executed", "query": query}
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate Flux query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        return any(op in query for op in ["from", "range", "filter", "aggregate", "yield"])
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get Flux query execution plan."""
+        return {
+            "query_type": "Flux",
+            "complexity": "MEDIUM",
+            "estimated_cost": 110
+        }
+    
+    def select_query(self, table: str, columns: List[str], where_clause: str = None) -> Any:
+        """Execute SELECT query."""
+        return self.execute(f"from(bucket: \"{table}\") | filter(fn: (r) => r._field =~ /{columns[0]}/)")
+    
+    def insert_query(self, table: str, data: Dict[str, Any]) -> Any:
+        """Execute INSERT query."""
+        return self.execute(f"INSERT INTO {table} VALUES {data}")
+    
+    def update_query(self, table: str, data: Dict[str, Any], where_clause: str = None) -> Any:
+        """Execute UPDATE query."""
+        return self.execute(f"UPDATE {table} SET {data}")
+    
+    def delete_query(self, table: str, where_clause: str = None) -> Any:
+        """Execute DELETE query."""
+        return self.execute(f"DELETE FROM {table}")
+    
+    def join_query(self, tables: List[str], join_conditions: List[str]) -> Any:
+        """Execute JOIN query."""
+        return self.execute(f"join(tables: {{t1: {tables[0]}, t2: {tables[1]}}})")
+    
+    def aggregate_query(self, table: str, functions: List[str], group_by: List[str] = None) -> Any:
+        """Execute aggregate query."""
+        return self.execute(f"from(bucket: \"{table}\") | aggregateWindow(every: 1m, fn: {functions[0]})")

exonware/xwnode/strategies/queries/gql.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+GQL Query Strategy
+
+This module implements the GQL query strategy for ISO/IEC 39075:2024 Graph Query Language operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+from typing import Any, Dict, List, Optional
+from .base import AGraphQueryStrategy
+from ...errors import XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class GQLStrategy(AGraphQueryStrategy):
+    """GQL query strategy for ISO/IEC 39075:2024 Graph Query Language operations."""
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.GQL
+        self._traits = QueryTrait.GRAPH | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute GQL query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid GQL query: {query}")
+        return {"result": "GQL query executed", "query": query}
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate GQL query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        return any(op in query.upper() for op in ["MATCH", "SELECT", "WHERE", "RETURN", "CREATE", "DELETE"])
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get GQL query execution plan."""
+        return {
+            "query_type": "GQL",
+            "complexity": "HIGH",
+            "estimated_cost": 150
+        }
+    
+    def match_query(self, pattern: str, where_clause: str = None) -> Any:
+        """Execute MATCH query."""
+        return self.execute(f"MATCH {pattern}")
+    
+    def create_query(self, pattern: str) -> Any:
+        """Execute CREATE query."""
+        return self.execute(f"CREATE {pattern}")
+    
+    def delete_query(self, pattern: str) -> Any:
+        """Execute DELETE query."""
+        return self.execute(f"DELETE {pattern}")
+    
+    def set_query(self, pattern: str) -> Any:
+        """Execute SET query."""
+        return self.execute(f"SET {pattern}")
+    
+    def remove_query(self, pattern: str) -> Any:
+        """Execute REMOVE query."""
+        return self.execute(f"REMOVE {pattern}")
+    
+    def merge_query(self, pattern: str) -> Any:
+        """Execute MERGE query."""
+        return self.execute(f"MERGE {pattern}")

exonware/xwnode/strategies/queries/graphql.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+GraphQL Query Strategy
+
+This module implements the GraphQL query strategy for graph-based data queries.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.12
+Generation Date: January 2, 2025
+"""
+
+import re
+from typing import Any, Dict, List, Optional, Union
+from .base import AGraphQueryStrategy
+from ...errors import XWNodeTypeError, XWNodeValueError
+from ...contracts import QueryMode, QueryTrait
+
+
+class GraphQLStrategy(AGraphQueryStrategy):
+    """
+    GraphQL query strategy for graph-based data queries.
+    
+    Supports:
+    - Queries and mutations
+    - Fragments and variables
+    - Introspection
+    - Subscriptions
+    - Schema validation
+    """
+    
+    def __init__(self, **options):
+        super().__init__(**options)
+        self._mode = QueryMode.GRAPHQL
+        self._traits = QueryTrait.GRAPH | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
+    
+    def execute(self, query: str, **kwargs) -> Any:
+        """Execute GraphQL query."""
+        if not self.validate_query(query):
+            raise XWNodeValueError(f"Invalid GraphQL query: {query}")
+        
+        query_type = self._get_query_type(query)
+        
+        if query_type == "query":
+            return self._execute_query(query, **kwargs)
+        elif query_type == "mutation":
+            return self._execute_mutation(query, **kwargs)
+        elif query_type == "subscription":
+            return self._execute_subscription(query, **kwargs)
+        else:
+            raise XWNodeValueError(f"Unsupported query type: {query_type}")
+    
+    def validate_query(self, query: str) -> bool:
+        """Validate GraphQL query syntax."""
+        if not query or not isinstance(query, str):
+            return False
+        
+        # Basic GraphQL validation
+        query = query.strip()
+        
+        # Check for valid GraphQL operations
+        valid_operations = ["query", "mutation", "subscription"]
+        for operation in valid_operations:
+            if query.startswith(operation) or query.startswith("{"):
+                return True
+        
+        return False
+    
+    def get_query_plan(self, query: str) -> Dict[str, Any]:
+        """Get GraphQL query execution plan."""
+        query_type = self._get_query_type(query)
+        
+        return {
+            "query_type": query_type,
+            "operation": query_type,
+            "complexity": self._estimate_complexity(query),
+            "estimated_cost": self._estimate_cost(query),
+            "fields": self._extract_fields(query),
+            "optimization_hints": self._get_optimization_hints(query)
+        }
+    
+    def path_query(self, start: Any, end: Any) -> List[Any]:
+        """Execute path query."""
+        query = f"""
+        query {{
+            path(start: "{start}", end: "{end}") {{
+                nodes
+                edges
+                cost
+            }}
+        }}
+        """
+        return self.execute(query)
+    
+    def neighbor_query(self, node: Any) -> List[Any]:
+        """Execute neighbor query."""
+        query = f"""
+        query {{
+            node(id: "{node}") {{
+                neighbors {{
+                    id
+                    properties
+                }}
+            }}
+        }}
+        """
+        return self.execute(query)
+    
+    def shortest_path_query(self, start: Any, end: Any) -> List[Any]:
+        """Execute shortest path query."""
+        query = f"""
+        query {{
+            shortestPath(start: "{start}", end: "{end}") {{
+                path
+                distance
+                hops
+            }}
+        }}
+        """
+        return self.execute(query)
+    
+    def connected_components_query(self) -> List[List[Any]]:
+        """Execute connected components query."""
+        query = """
+        query {
+            connectedComponents {
+                components {
+                    nodes
+                    size
+                }
+            }
+        }
+        """
+        return self.execute(query)
+    
+    def cycle_detection_query(self) -> List[List[Any]]:
+        """Execute cycle detection query."""
+        query = """
+        query {
+            cycles {
+                cycles {
+                    nodes
+                    length
+                }
+            }
+        }
+        """
+        return self.execute(query)
+    
+    def _get_query_type(self, query: str) -> str:
+        """Extract query type from GraphQL query."""
+        query = query.strip()
+        
+        if query.startswith("mutation"):
+            return "mutation"
+        elif query.startswith("subscription"):
+            return "subscription"
+        elif query.startswith("query") or query.startswith("{"):
+            return "query"
+        else:
+            return "unknown"
+    
+    def _execute_query(self, query: str, **kwargs) -> Any:
+        """Execute GraphQL query."""
+        return {"result": "GraphQL query executed", "query": query}
+    
+    def _execute_mutation(self, query: str, **kwargs) -> Any:
+        """Execute GraphQL mutation."""
+        return {"result": "GraphQL mutation executed", "query": query}
+    
+    def _execute_subscription(self, query: str, **kwargs) -> Any:
+        """Execute GraphQL subscription."""
+        return {"result": "GraphQL subscription executed", "query": query}
+    
+    def _estimate_complexity(self, query: str) -> str:
+        """Estimate query complexity."""
+        # Count nested fields and connections
+        depth = self._calculate_query_depth(query)
+        
+        if depth > 5:
+            return "HIGH"
+        elif depth > 2:
+            return "MEDIUM"
+        else:
+            return "LOW"
+    
+    def _estimate_cost(self, query: str) -> int:
+        """Estimate query cost."""
+        complexity = self._estimate_complexity(query)
+        if complexity == "HIGH":
+            return 150
+        elif complexity == "MEDIUM":
+            return 75
+        else:
+            return 25
+    
+    def _calculate_query_depth(self, query: str) -> int:
+        """Calculate query nesting depth."""
+        depth = 0
+        max_depth = 0
+        
+        for char in query:
+            if char == '{':
+                depth += 1
+                max_depth = max(max_depth, depth)
+            elif char == '}':
+                depth -= 1
+        
+        return max_depth
+    
+    def _extract_fields(self, query: str) -> List[str]:
+        """Extract field names from GraphQL query."""
+        # Simple field extraction
+        fields = []
+        lines = query.split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith('{') and not line.startswith('}'):
+                if ':' in line:
+                    field = line.split(':')[0].strip()
+                    fields.append(field)
+        
+        return fields
+    
+    def _get_optimization_hints(self, query: str) -> List[str]:
+        """Get query optimization hints."""
+        hints = []
+        
+        if self._calculate_query_depth(query) > 3:
+            hints.append("Consider reducing query depth to improve performance")
+        
+        if "..." in query:
+            hints.append("Consider using fragments for reusable query parts")
+        
+        if query.count('{') > 10:
+            hints.append("Consider breaking down complex queries into smaller ones")
+        
+        return hints