tellaro-query-language 0.1.4__tar.gz → 0.1.6__tar.gz

{tellaro_query_language-0.1.4 → tellaro_query_language-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tellaro-query-language
-Version: 0.1.4
+Version: 0.1.6
 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.4 → tellaro_query_language-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tellaro-query-language"
-version = "0.1.4"
+version = "0.1.6"
 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.4 → tellaro_query_language-0.1.6}/src/tql/core_components/stats_operations.py

@@ -38,15 +38,27 @@ class StatsOperations:
             TQLParseError: If query parsing fails
             TQLValueError: If query is invalid
         """
-        # Ensure the query starts with | stats
-        if not stats_query.strip().startswith("| stats"):
-            stats_query = "| stats " + stats_query.strip()
-
-        # Parse the stats expression
+        # First try to parse as-is
         try:
             parsed = self.parser.parse(stats_query)
-        except TQLParseError as e:
-            raise TQLParseError(f"Invalid stats query: {str(e)}")
+            # If it's already a stats expression, use it
+            if parsed.get("type") == "stats_expr":
+                # Already a valid stats expression, proceed
+                pass
+            else:
+                # Not a stats expression, try adding | stats prefix
+                stats_query_with_pipe = "| stats " + stats_query.strip()
+                parsed = self.parser.parse(stats_query_with_pipe)
+        except TQLParseError:
+            # If parsing failed, try with | stats prefix
+            if not stats_query.strip().startswith("| stats"):
+                stats_query_with_pipe = "| stats " + stats_query.strip()
+                try:
+                    parsed = self.parser.parse(stats_query_with_pipe)
+                except TQLParseError as e:
+                    raise TQLParseError(f"Invalid stats query: {str(e)}")
+            else:
+                raise
 
         # Verify it's a stats expression
         if parsed.get("type") != "stats_expr":

{tellaro_query_language-0.1.4 → tellaro_query_language-0.1.6}/src/tql/parser.py

@@ -123,6 +123,10 @@ class TQLParser:
                 # Single item, check if it's a field with is_private/is_global mutator
                 item = parsed[0]
                 if isinstance(item, list):
+                    # Check if this is a stats expression (starts with 'stats')
+                    if len(item) >= 2 and isinstance(item[0], str) and item[0].lower() == "stats":
+                        # This is a stats expression without filter
+                        return self._build_stats_ast(item)
                     # Could be a typed_field
                     field_name, type_hint, field_mutators = self.ast_builder.extract_field_info(item)
                     if field_mutators:
@@ -1219,8 +1223,23 @@ class TQLParser:
                 result["aggregations"].append({"function": "count", "field": "*", "alias": None})
                 i += 1
             elif isinstance(parsed[i], list):
-                # This is a list of aggregations
-                for item in parsed[i]:
+                # Check if this is a single aggregation with alias pattern
+                # Pattern: [['func', 'field'], 'as', 'alias'] or ['count', 'as', 'alias']
+                if (
+                    len(parsed[i]) >= 3
+                    and isinstance(parsed[i][1], str)
+                    and parsed[i][1].lower() == "as"
+                    and (
+                        isinstance(parsed[i][0], list)
+                        or (isinstance(parsed[i][0], str) and parsed[i][0].lower() == "count")
+                    )
+                ):
+                    # This is a single aggregation with alias
+                    items_to_process = [parsed[i]]
+                else:
+                    # This is a list of aggregations
+                    items_to_process = parsed[i]
+                for item in items_to_process:
                     agg_dict: Dict[str, Any] = {}
 
                     if isinstance(item, str) and item.lower() == "count":
@@ -1228,6 +1247,17 @@ class TQLParser:
                         agg_dict["function"] = "count"
                         agg_dict["field"] = "*"
                         agg_dict["alias"] = None
+                    elif (
+                        isinstance(item, list)
+                        and len(item) >= 3
+                        and isinstance(item[0], str)
+                        and item[0].lower() == "count"
+                        and item[1].lower() == "as"
+                    ):
+                        # count(*) with alias: ['count', 'as', 'alias']
+                        agg_dict["function"] = "count"
+                        agg_dict["field"] = "*"
+                        agg_dict["alias"] = item[2]
                     elif isinstance(item, list):
                         # Regular aggregation: [func, field, ...] or [[func, field], 'as', 'alias']
                         if len(item) >= 2 and isinstance(item[0], list):

{tellaro_query_language-0.1.4 → tellaro_query_language-0.1.6}/src/tql/parser_components/grammar.py

@@ -375,7 +375,8 @@ class TQLGrammar:
         # Aggregation function names - including aliases
         self.agg_function_name = oneOf(
             "count unique_count sum min max average avg median med std standard_deviation "
-            "percentile percentiles p pct percentile_rank percentile_ranks pct_rank pct_ranks",
+            "percentile percentiles p pct percentile_rank percentile_ranks pct_rank pct_ranks "
+            "values unique cardinality",
             caseless=True,
         )
 
@@ -407,10 +408,18 @@ class TQLGrammar:
         self.group_by_fields = delimitedList(self.field_name)
 
         # Complete stats expression: | stats agg_functions [by group_fields]
-        self.stats_expr = Group(
+        self.stats_expr_with_pipe = Group(
             Suppress("|") + self.stats_kw + self.agg_list + PyparsingOptional(self.by_kw + self.group_by_fields)
         )
 
+        # Stats expression without pipe (for standalone use)
+        self.stats_expr_no_pipe = Group(
+            self.stats_kw + self.agg_list + PyparsingOptional(self.by_kw + self.group_by_fields)
+        )
+
+        # Combined stats expression (with or without pipe)
+        self.stats_expr = self.stats_expr_with_pipe | self.stats_expr_no_pipe
+
     def _setup_final_expressions(self):
         """Set up final expression definitions."""
         # Define all forms of comparison
@@ -447,8 +456,9 @@ class TQLGrammar:
         self.tql_expr << (
             # filter | stats
             (
-                Group(self.filter_expr + self.stats_expr)  # filter | stats
-                | self.stats_expr  # just stats (applies to all records)
+                self.stats_expr_no_pipe  # just stats without pipe (applies to all records)
+                | Group(self.filter_expr + self.stats_expr_with_pipe)  # filter | stats
+                | self.stats_expr  # just stats with pipe (applies to all records)
                 | self.filter_expr
             )  # just filter (no stats)
         )

{tellaro_query_language-0.1.4 → tellaro_query_language-0.1.6}/src/tql/stats_evaluator.py

@@ -40,7 +40,7 @@ class TQLStatsEvaluator:
     }
 
     # Aggregation functions that work with any field type
-    ANY_TYPE_AGGREGATIONS = {"count", "unique_count"}
+    ANY_TYPE_AGGREGATIONS = {"count", "unique_count", "values", "unique", "cardinality"}
 
     # Numeric types supported by OpenSearch
     NUMERIC_TYPES = {
@@ -281,6 +281,17 @@ class TQLStatsEvaluator:
                 for v in rank_values:
                     result[f"rank_{v}"] = self._calculate_percentile_rank(numeric_values, v)
                 return result
+        elif func in ["values", "unique", "cardinality"]:
+            # Return unique values from the field
+            unique_values = list(set(values)) if values else []
+            # Sort the values for consistent output
+            try:
+                # Try to sort if values are comparable
+                unique_values.sort()
+            except TypeError:
+                # If values aren't comparable (mixed types), just return unsorted
+                pass
+            return unique_values
         else:
             raise TQLError(f"Unsupported aggregation function: {func}")