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

exonware/xwnode/queries/strategies/gql.py

@@ -1,70 +0,0 @@
-#!/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.21
-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/queries/strategies/graphql.py

@@ -1,240 +0,0 @@
-#!/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.21
-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

exonware/xwnode/queries/strategies/gremlin.py

@@ -1,181 +0,0 @@
-#!/usr/bin/env python3
-"""
-Gremlin Query Strategy
-
-This module implements the Gremlin query strategy for Apache TinkerPop graph queries.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-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 GremlinStrategy(AGraphQueryStrategy):
-    """
-    Gremlin query strategy for Apache TinkerPop graph queries.
-    
-    Supports:
-    - Gremlin traversal language
-    - Graph traversal operations
-    - Vertex and edge operations
-    - Property and label operations
-    - Path and cycle detection
-    """
-    
-    def __init__(self, **options):
-        super().__init__(**options)
-        self._mode = QueryMode.GREMLIN
-        self._traits = QueryTrait.GRAPH | QueryTrait.STRUCTURED | QueryTrait.ANALYTICAL
-    
-    def execute(self, query: str, **kwargs) -> Any:
-        """Execute Gremlin query."""
-        if not self.validate_query(query):
-            raise XWNodeValueError(f"Invalid Gremlin query: {query}")
-        
-        query_type = self._get_query_type(query)
-        
-        if query_type == "traversal":
-            return self._execute_traversal(query, **kwargs)
-        elif query_type == "vertex":
-            return self._execute_vertex(query, **kwargs)
-        elif query_type == "edge":
-            return self._execute_edge(query, **kwargs)
-        else:
-            raise XWNodeValueError(f"Unsupported query type: {query_type}")
-    
-    def validate_query(self, query: str) -> bool:
-        """Validate Gremlin query syntax."""
-        if not query or not isinstance(query, str):
-            return False
-        
-        # Basic Gremlin validation
-        query = query.strip()
-        
-        # Check for Gremlin keywords
-        gremlin_keywords = ["g.", "V", "E", "addV", "addE", "drop", "has", "hasLabel", "hasId", "out", "in", "both", "outE", "inE", "bothE", "outV", "inV", "bothV", "values", "key", "label", "id", "count", "limit", "range", "order", "by", "select", "where", "and", "or", "not", "is", "within", "without", "between", "inside", "outside", "within", "without", "between", "inside", "outside", "within", "without", "between", "inside", "outside"]
-        
-        for keyword in gremlin_keywords:
-            if keyword in query:
-                return True
-        
-        return False
-    
-    def get_query_plan(self, query: str) -> Dict[str, Any]:
-        """Get Gremlin 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),
-            "steps": self._extract_steps(query),
-            "optimization_hints": self._get_optimization_hints(query)
-        }
-    
-    def path_query(self, start: Any, end: Any) -> List[Any]:
-        """Execute path query."""
-        query = f"g.V('{start}').repeat(out()).until(hasId('{end}')).path()"
-        return self.execute(query)
-    
-    def neighbor_query(self, node: Any) -> List[Any]:
-        """Execute neighbor query."""
-        query = f"g.V('{node}').both()"
-        return self.execute(query)
-    
-    def shortest_path_query(self, start: Any, end: Any) -> List[Any]:
-        """Execute shortest path query."""
-        query = f"g.V('{start}').repeat(out()).until(hasId('{end}')).path().limit(1)"
-        return self.execute(query)
-    
-    def connected_components_query(self) -> List[List[Any]]:
-        """Execute connected components query."""
-        query = "g.V().repeat(both()).until(cyclicPath()).dedup()"
-        return self.execute(query)
-    
-    def cycle_detection_query(self) -> List[List[Any]]:
-        """Execute cycle detection query."""
-        query = "g.V().repeat(out()).until(cyclicPath()).path()"
-        return self.execute(query)
-    
-    def _get_query_type(self, query: str) -> str:
-        """Extract query type from Gremlin query."""
-        query = query.strip()
-        
-        if "V(" in query or "E(" in query:
-            return "traversal"
-        elif "addV" in query or "V(" in query:
-            return "vertex"
-        elif "addE" in query or "E(" in query:
-            return "edge"
-        else:
-            return "unknown"
-    
-    def _execute_traversal(self, query: str, **kwargs) -> Any:
-        """Execute traversal query."""
-        return {"result": "Gremlin traversal executed", "query": query}
-    
-    def _execute_vertex(self, query: str, **kwargs) -> Any:
-        """Execute vertex query."""
-        return {"result": "Gremlin vertex executed", "query": query}
-    
-    def _execute_edge(self, query: str, **kwargs) -> Any:
-        """Execute edge query."""
-        return {"result": "Gremlin edge executed", "query": query}
-    
-    def _estimate_complexity(self, query: str) -> str:
-        """Estimate query complexity."""
-        steps = self._extract_steps(query)
-        
-        if len(steps) > 10:
-            return "HIGH"
-        elif len(steps) > 5:
-            return "MEDIUM"
-        else:
-            return "LOW"
-    
-    def _estimate_cost(self, query: str) -> int:
-        """Estimate query cost."""
-        complexity = self._estimate_complexity(query)
-        if complexity == "HIGH":
-            return 180
-        elif complexity == "MEDIUM":
-            return 90
-        else:
-            return 45
-    
-    def _extract_steps(self, query: str) -> List[str]:
-        """Extract Gremlin steps from query."""
-        steps = []
-        
-        # Common Gremlin steps
-        gremlin_steps = ["V", "E", "addV", "addE", "drop", "has", "hasLabel", "hasId", "out", "in", "both", "outE", "inE", "bothE", "outV", "inV", "bothV", "values", "key", "label", "id", "count", "limit", "range", "order", "by", "select", "where", "and", "or", "not", "is", "within", "without", "between", "inside", "outside", "repeat", "until", "emit", "times", "path", "dedup", "cyclicPath"]
-        
-        for step in gremlin_steps:
-            if step in query:
-                steps.append(step)
-        
-        return steps
-    
-    def _get_optimization_hints(self, query: str) -> List[str]:
-        """Get query optimization hints."""
-        hints = []
-        
-        if "repeat" in query:
-            hints.append("Consider using limit() with repeat() to prevent infinite loops")
-        
-        if "path" in query:
-            hints.append("Consider using dedup() with path() to avoid duplicate paths")
-        
-        if "count" in query:
-            hints.append("Consider using count() early in the traversal for better performance")
-        
-        return hints