tellaro-query-language 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

{tellaro_query_language-0.1.4.dist-info → tellaro_query_language-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tellaro-query-language
-Version: 0.1.4
+Version: 0.1.5
 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.dist-info → tellaro_query_language-0.1.5.dist-info}/RECORD

@@ -9,7 +9,7 @@ tql/core_components/README.md,sha256=Rm7w4UHdQ0vPBEFybE5b62IOvSA5Nzq2GRvtBHOapmc
 tql/core_components/__init__.py,sha256=v8BBybPlqV7dkVY9mw1mblvqyAFJZ7Pf_bEc-jAL7FI,643
 tql/core_components/file_operations.py,sha256=Jr0kkxz_OP2KHOAsIr7KMtYe_lbu8LuBUySt2LQbjJw,3925
 tql/core_components/opensearch_operations.py,sha256=x0GPdQfMX-NYCzzAlJCbtzYFa6HmaKxGEVl2JdAhKJY,35447
-tql/core_components/stats_operations.py,sha256=jNk7cQZLwwsIoN__hdFHME8e17AjDHYLvZ-5kwPxNUY,6853
+tql/core_components/stats_operations.py,sha256=9WSEMdAvtZA6deckGwyetPAtnDODFqlnrhvlBbNkBcs,7469
 tql/core_components/validation_operations.py,sha256=_VPXh0HABBjsXF99jFT7B6-5QAPsADOCy6poinGrxeE,22454
 tql/evaluator.py,sha256=YdgS1vuxUEPAHhUsZey-Y4NydeS8CTYOy_O8R5_K8cE,15421
 tql/evaluator_components/README.md,sha256=c59yf2au34yPhrru7JWgGop_ORteB6w5vfMhsac8j3k,3882
@@ -37,20 +37,20 @@ tql/opensearch_components/lucene_converter.py,sha256=ZbupWZ2smGhWfE9cSIrNo7MZVY3
 tql/opensearch_components/query_converter.py,sha256=9Nkhehb8X7jIQcyRaHCa5WCKWtovdRGKuSdDsBulrG0,36722
 tql/opensearch_mappings.py,sha256=zJCCdMrxK7mswrkxd5LiOhunQ9GIJNZdhktVoGXgVgk,11529
 tql/opensearch_stats.py,sha256=svcE23lD1gDe1iYGlC388WE8X3x9C8tjfBylUVy2Uqo,17216
-tql/parser.py,sha256=6WbCpMuYOJymSYHEgTFS7yTgCOPXsCmGsi9m_u5oQzc,73954
+tql/parser.py,sha256=dnjgc-sDVihe-VIVPT_SRULeng4OWaLtkbM23dluT6M,75532
 tql/parser_components/README.md,sha256=lvQX72ckq2zyotGs8QIHHCIFqaA7bOHwkP44wU8Zoiw,2322
 tql/parser_components/__init__.py,sha256=zBwHBMPJyHSBbaOojf6qTrJYjJg5A6tPUE8nHFdRiQs,521
 tql/parser_components/ast_builder.py,sha256=-pbcYhZNoRm0AnjmJRAAlXLCAwHfauchTpX_6KO0plE,6793
 tql/parser_components/error_analyzer.py,sha256=qlCD9vKyW73aeKQYI33P1OjIWSJ3LPd08wuN9cis2fU,4012
 tql/parser_components/field_extractor.py,sha256=TumeuUo2c5gPYVbTPsmU43C3TJFC8chAAWERu5v_Q3c,4182
-tql/parser_components/grammar.py,sha256=bfThefrhdbCMPLWb9ZXwZDXx8ZW8_PXihjwCL-P3Gi8,18669
+tql/parser_components/grammar.py,sha256=WtmgANV49Jx1uHNBeiyElpXqKy3feQOWj9aYdxGn3Ww,19182
 tql/post_processor.py,sha256=-vA2wgbuLij2FVnj5I9HDHtw5bKj9Cu3EE9mtoeSWk8,28859
 tql/scripts.py,sha256=VOr5vCjIvKlW36kwvJx7JGFIRM16IJZlbJcWlBexBtk,3728
-tql/stats_evaluator.py,sha256=7ymCebPOepY3QKHGz0QEhkTmYYHjck648rrI8cWhhDI,15158
+tql/stats_evaluator.py,sha256=GtmygLdPPMhAMR5bN1h69cQsNBYqg-jQl6bN5rwEx6Q,15692
 tql/stats_transformer.py,sha256=MT-4rDWZSySgn4Fuq9H0c-mvwFYLM6FqWpPv2rHX-rE,7588
 tql/validators.py,sha256=e9MlX-zQ_O3M8YP8vXyMjKU8iiJMTh6mMK0iv0_4gTY,3771
-tellaro_query_language-0.1.4.dist-info/LICENSE,sha256=zRhQ85LnW55fWgAjQctckwQ67DX5Jmt64lq343ThZFU,1063
-tellaro_query_language-0.1.4.dist-info/METADATA,sha256=vpS-ejEu2AU7SSXTML7q0x9jFwm3zZo13MwfLQxCPyI,15109
-tellaro_query_language-0.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-tellaro_query_language-0.1.4.dist-info/entry_points.txt,sha256=H43APfGBMsZkKsUCnFTaqprQPW-Kce2yz2qsBL3dZrw,164
-tellaro_query_language-0.1.4.dist-info/RECORD,,
+tellaro_query_language-0.1.5.dist-info/LICENSE,sha256=zRhQ85LnW55fWgAjQctckwQ67DX5Jmt64lq343ThZFU,1063
+tellaro_query_language-0.1.5.dist-info/METADATA,sha256=QPSlAjalj-9Q3VWOBx2DVcQwogyR3e6OlI7vHk_2sxw,15109
+tellaro_query_language-0.1.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+tellaro_query_language-0.1.5.dist-info/entry_points.txt,sha256=H43APfGBMsZkKsUCnFTaqprQPW-Kce2yz2qsBL3dZrw,164
+tellaro_query_language-0.1.5.dist-info/RECORD,,

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":

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):

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)
         )

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}")