tellaro-query-language 0.1.2__tar.gz → 0.1.3__tar.gz

{tellaro_query_language-0.1.2 → tellaro_query_language-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tellaro-query-language
-Version: 0.1.2
+Version: 0.1.3
 Summary: A flexible, human-friendly query language for searching and filtering structured data
 Home-page: https://github.com/tellaro/tellaro-query-language
 License: MIT

{tellaro_query_language-0.1.2 → tellaro_query_language-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tellaro-query-language"
-version = "0.1.2"
+version = "0.1.3"
 description = "A flexible, human-friendly query language for searching and filtering structured data"
 authors = ["Justin Henderson <justin@tellaro.io>"]
 license = "MIT"

{tellaro_query_language-0.1.2 → tellaro_query_language-0.1.3}/src/tql/core.py

@@ -12,6 +12,7 @@ from .evaluator import TQLEvaluator
 from .exceptions import TQLOperatorError, TQLParseError, TQLSyntaxError, TQLTypeError, TQLValidationError
 from .mutator_analyzer import MutatorAnalysisResult
 from .parser import TQLParser
+from .stats_evaluator import TQLStatsEvaluator
 
 
 class TQL:
@@ -53,6 +54,7 @@ class TQL:
         """
         self.parser = TQLParser()
         self.evaluator = TQLEvaluator()
+        self.stats_evaluator = TQLStatsEvaluator()
         self.field_mappings = field_mappings or {}
 
         # Create enhanced field mappings for optimization
@@ -165,16 +167,25 @@ class TQL:
             return f"NOT {operand}"
         return str(ast)
 
-    def query(self, data: Union[List[Dict], str], query: str, save_enrichment: bool = False) -> List[Dict[str, Any]]:
-        """Execute a TQL query against data and return matching records.
+    def query(
+        self, data: Union[List[Dict], str], query: str, size: int = 10, save_enrichment: bool = False
+    ) -> Dict[str, Any]:  # noqa: C901
+        """Execute a TQL query against data and return results in execute_opensearch format.
 
         Args:
             data: List of dictionaries or path to JSON/CSV file
-            query: TQL query string
+            query: TQL query string (can be filter query, stats query, or combined)
+            size: Number of documents to return (0 for stats-only queries)
             save_enrichment: If True and mutators add enrichment fields, save back to source
 
         Returns:
-            List of records matching the query
+            Dictionary containing:
+            - results: List of matching records (if size > 0 and no stats)
+            - stats: Stats results (if query contains stats)
+            - total: Total number of matching documents
+            - post_processing_applied: Whether post-processing was applied
+            - health_status: Query health status
+            - health_reasons: List of health issues
 
         Raises:
             TQLParseError: If query parsing fails
@@ -183,6 +194,9 @@ class TQL:
         # Parse the query
         ast = self.parse(query)
 
+        # Check query type
+        query_type = ast.get("type")
+
         # Load data if it's a file path
         if isinstance(data, str):
             records = self.file_ops.load_file(data)
@@ -191,23 +205,64 @@ class TQL:
             records = data
             source_file = None
 
-        # Execute the query
-        results = []
-        has_enrichments = False
+        # Initialize result structure
+        result = {"total": 0, "post_processing_applied": False, "health_status": "green", "health_reasons": []}
 
-        # Field mappings will be passed to evaluator methods
+        # Handle stats queries
+        if query_type == "stats_expr":
+            # This is a pure stats query like "| stats count()"
+            stats_result = self.stats(data, query)
+            # Convert to execute_opensearch format
+            result["stats"] = self._convert_stats_result(stats_result)
+            result["total"] = len(records)
+            return result
+
+        elif query_type == "query_with_stats":
+            # This is a combined query like "status = 'active' | stats count()"
+            # First filter the data
+            parsed = self.parse(query)
+            filter_ast = parsed["filter"]
+            stats_ast = parsed["stats"]
+
+            # Apply filter
+            filtered_records = []
+            for record in records:
+                if self.evaluator._evaluate_node(filter_ast, record, self._simple_mappings):
+                    filtered_records.append(record)
+
+            # Apply stats to filtered data
+            stats_result = self.stats_evaluator.evaluate_stats(filtered_records, stats_ast)
+            result["stats"] = self._convert_stats_result(stats_result)
+            result["total"] = len(filtered_records)
+
+            # Include filtered documents if size > 0
+            if size > 0:
+                result["results"] = filtered_records[:size]
+
+            return result
+
+        # Handle regular filter queries
+        matched_records = []
+        has_enrichments = False
 
         for record in records:
             # Check if record matches
             if self.evaluator._evaluate_node(ast, record, self._simple_mappings):
                 # Apply any mutators to enrich the record
                 enriched_record = self._apply_mutators_to_record(ast, record)
-                results.append(enriched_record)
+                matched_records.append(enriched_record)
                 # Check if enrichments were added
                 if not has_enrichments and enriched_record is not record:
                     has_enrichments = True
 
-        # No need to restore mappings since we pass them as parameters
+        # Set result data
+        result["total"] = len(matched_records)
+        if size > 0:
+            result["results"] = matched_records[:size]
+
+        # Check if post-processing (mutators) were applied
+        if has_enrichments:
+            result["post_processing_applied"] = True
 
         # Save enrichments if requested
         if save_enrichment and has_enrichments and source_file:
@@ -221,7 +276,7 @@ class TQL:
             if source_file.lower().endswith(".json"):
                 self.file_ops.save_enrichments_to_json(source_file, all_enriched)
 
-        return results
+        return result
 
     def query_single(self, record: Dict[str, Any], query: str) -> bool:
         """Check if a single record matches a TQL query.
@@ -927,3 +982,30 @@ class TQL:
         # For now, return the original record
         # TODO: Implement mutator application for enrichment  # noqa: W0511
         return record
+
+    def _convert_stats_result(self, stats_result: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert stats result from query() format to execute_opensearch format.
+
+        Args:
+            stats_result: Result from stats() or query_stats() method
+
+        Returns:
+            Stats result in execute_opensearch format
+        """
+        # Map the stats evaluator format to execute_opensearch format
+        if stats_result.get("type") == "simple_aggregation":
+            return {
+                "type": "stats",
+                "operation": stats_result["function"],
+                "field": stats_result["field"],
+                "values": stats_result["value"],
+            }
+        elif stats_result.get("type") == "multiple_aggregations":
+            # For multiple aggregations, return the results dict
+            return {"type": "stats_multiple", "results": stats_result["results"]}
+        elif stats_result.get("type") == "grouped_aggregation":
+            # For grouped aggregations
+            return {"type": "stats_grouped", "group_by": stats_result["group_by"], "results": stats_result["results"]}
+        else:
+            # Return as-is if format is unknown
+            return stats_result