pytrilogy 0.0.3.48__tar.gz → 0.0.3.52__tar.gz

{pytrilogy-0.0.3.48/pytrilogy.egg-info → pytrilogy-0.0.3.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.48
+Version: 0.0.3.52
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.48
+Version: 0.0.3.52
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/tests/test_functions.py

@@ -214,6 +214,8 @@ def test_math_functions(test_environment):
     property order_id.order_nested <- revenue * 2/2;
     property order_id.rounded <- round(revenue + 2.01,2);
     property order_id.rounded_default <- round(revenue + 2.01);
+    property order_id.floor <- floor(revenue + 2.01);
+    property order_id.ceil <- ceil(revenue + 2.01);
     constant random <- random(1);
     select
         order_id,
@@ -224,6 +226,8 @@ def test_math_functions(test_environment):
         order_add,
         rounded,
         rounded_default,
+        floor,
+        ceil,
         random,
     ;"""
     env, parsed = parse(declarations, environment=test_environment)

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/tests/test_parse_engine.py

@@ -2,7 +2,12 @@ from pytest import raises
 
 from trilogy.core.exceptions import UndefinedConceptException
 from trilogy.core.models.environment import Environment
-from trilogy.parsing.parse_engine import PARSER, ParseToObjects, unpack_visit_error
+from trilogy.parsing.parse_engine import (
+    PARSER,
+    InvalidSyntaxException,
+    ParseToObjects,
+    unpack_visit_error,
+)
 
 TEXT = """
 const a <- 1;
@@ -29,3 +34,20 @@ def test_parser():
         with raises(UndefinedConceptException):
             unpack_visit_error(e)
     assert failed
+
+
+TEXT2 = """
+const a <- 1;
+
+select
+    a,
+FROM a
+;
+"""
+
+
+def test_from_error():
+    env = Environment()
+
+    with raises(InvalidSyntaxException):
+        env.parse(TEXT2)

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/tests/test_parsing.py

@@ -92,7 +92,12 @@ def test_arg_to_datatype():
 
 
 def test_argument_to_purpose(test_environment: Environment):
-    assert argument_to_purpose(1.00) == Purpose.CONSTANT
+    assert (
+        argument_to_purpose(
+            1.00,
+        )
+        == Purpose.CONSTANT
+    )
     assert argument_to_purpose("test") == Purpose.CONSTANT
     assert argument_to_purpose(test_environment.concepts["order_id"]) == Purpose.KEY
     assert (
@@ -100,19 +105,22 @@ def test_argument_to_purpose(test_environment: Environment):
             [
                 "test",
                 1.00,
-            ]
+            ],
+            test_environment,
         )
         == Purpose.CONSTANT
     )
     assert (
         function_args_to_output_purpose(
-            ["test", 1.00, test_environment.concepts["order_id"]]
+            ["test", 1.00, test_environment.concepts["order_id"]], test_environment
         )
         == Purpose.PROPERTY
     )
     unnest_env, parsed = parse_text("const random <- unnest([1,2,3,4]);")
     assert (
-        function_args_to_output_purpose([unnest_env.concepts["random"]])
+        function_args_to_output_purpose(
+            [unnest_env.concepts["random"]], test_environment
+        )
         == Purpose.PROPERTY
     )
 

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.48"
+__version__ = "0.0.3.52"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/enums.py

@@ -131,6 +131,7 @@ class FunctionType(Enum):
     CONSTANT = "constant"
     COALESCE = "coalesce"
     IS_NULL = "isnull"
+    NULLIF = "nullif"
     BOOL = "bool"
 
     # COMPLEX
@@ -156,6 +157,8 @@ class FunctionType(Enum):
     ABS = "abs"
     SQRT = "sqrt"
     RANDOM = "random"
+    FLOOR = "floor"
+    CEIL = "ceil"
 
     # Aggregates
     ## group is not a real aggregate - it just means group by this + some other set of fields

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/functions.py

@@ -279,6 +279,12 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_purpose=Purpose.PROPERTY,
         arg_count=1,
     ),
+    FunctionType.NULLIF: FunctionConfig(
+        valid_inputs={*DataType},
+        output_purpose=Purpose.PROPERTY,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
+        arg_count=2,
+    ),
     FunctionType.COALESCE: FunctionConfig(
         valid_inputs={*DataType},
         output_purpose=Purpose.PROPERTY,
@@ -637,6 +643,22 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type_function=lambda args: get_output_type_at_index(args, 0),
         arg_count=2,
     ),
+    FunctionType.FLOOR: FunctionConfig(
+        valid_inputs=[
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.INTEGER,
+        arg_count=1,
+    ),
+    FunctionType.CEIL: FunctionConfig(
+        valid_inputs=[
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.INTEGER,
+        arg_count=1,
+    ),
     FunctionType.CUSTOM: FunctionConfig(
         output_purpose=Purpose.PROPERTY,
         arg_count=InfiniteFunctionArgs,
@@ -787,13 +809,14 @@ def create_function_derived_concept(
     namespace: str,
     operator: FunctionType,
     arguments: list[Concept],
+    environment: Environment,
     output_type: Optional[
         DataType | ListType | StructType | MapType | NumericType | TraitDataType
     ] = None,
     output_purpose: Optional[Purpose] = None,
 ) -> Concept:
     purpose = (
-        function_args_to_output_purpose(arguments)
+        function_args_to_output_purpose(arguments, environment=environment)
         if output_purpose is None
         else output_purpose
     )
@@ -846,13 +869,15 @@ def argument_to_purpose(arg) -> Purpose:
         raise ValueError(f"Cannot parse arg purpose for {arg} of type {type(arg)}")
 
 
-def function_args_to_output_purpose(args) -> Purpose:
+def function_args_to_output_purpose(args, environment: Environment) -> Purpose:
     has_metric = False
     has_non_constant = False
     has_non_single_row_constant = False
     if not args:
         return Purpose.CONSTANT
     for arg in args:
+        if isinstance(arg, ConceptRef):
+            arg = environment.concepts[arg.address]
         purpose = argument_to_purpose(arg)
         if purpose == Purpose.METRIC:
             has_metric = True

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/models/author.py

@@ -25,6 +25,7 @@ from pydantic import (
     ValidationInfo,
     computed_field,
     field_validator,
+    model_validator,
 )
 
 from trilogy.constants import DEFAULT_NAMESPACE, MagicConstants
@@ -621,8 +622,8 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
             return v.reference
         return v
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
+    @model_validator(mode="after")
+    def validate_comparison(self):
         if self.operator in (ComparisonOperator.IS, ComparisonOperator.IS_NOT):
             if self.right != MagicConstants.NULL and DataType.BOOL != arg_to_datatype(
                 self.right
@@ -632,7 +633,6 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                 )
         elif self.operator in (ComparisonOperator.IN, ComparisonOperator.NOT_IN):
             right_type = arg_to_datatype(self.right)
-
             if isinstance(right_type, ListType) and not is_compatible_datatype(
                 arg_to_datatype(self.left), right_type.value_data_type
             ):
@@ -653,6 +653,8 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                     f"Cannot compare {arg_to_datatype(self.left)} and {arg_to_datatype(self.right)} of different types with operator {self.operator} in {str(self)}"
                 )
 
+        return self
+
     def __add__(self, other):
         if other is None:
             return self
@@ -1022,7 +1024,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         keys = self.keys
 
         if self.is_aggregate and isinstance(new_lineage, Function) and grain.components:
-            grain_components = [
+            grain_components: list[ConceptRef | Concept] = [
                 environment.concepts[c].reference for c in grain.components
             ]
             new_lineage = AggregateWrapper(function=new_lineage, by=grain_components)
@@ -1847,9 +1849,6 @@ class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel)
     function: Function
     by: List[ConceptRef | Concept] = Field(default_factory=list)
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     @field_validator("by", mode="before")
     @classmethod
     def enforce_concept_ref(cls, v):
@@ -1945,11 +1944,15 @@ class FilterItem(DataTyped, Namespaced, ConceptArgs, BaseModel):
 
     @property
     def output_datatype(self):
-        return self.content.datatype
+        return arg_to_datatype(self.content)
 
     @property
     def concept_arguments(self):
-        return [self.content] + self.where.concept_arguments
+        if isinstance(self.content, ConceptRef):
+            return [self.content] + self.where.concept_arguments
+        elif isinstance(self.content, ConceptArgs):
+            return self.content.concept_arguments + self.where.concept_arguments
+        return self.where.concept_arguments
 
 
 class RowsetLineage(Namespaced, Mergeable, BaseModel):

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/models/build.py

@@ -262,11 +262,8 @@ class BuildGrain(BaseModel):
     components: set[str] = Field(default_factory=set)
     where_clause: Optional[BuildWhereClause] = None
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     def without_condition(self):
-        return BuildGrain(components=self.components)
+        return BuildGrain.model_construct(components=self.components)
 
     @classmethod
     def from_concepts(
@@ -321,12 +318,12 @@ class BuildGrain(BaseModel):
                 # raise NotImplementedError(
                 #     f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
                 # )
-        return BuildGrain(
+        return BuildGrain.model_construct(
             components=self.components.union(other.components), where_clause=where
         )
 
     def __sub__(self, other: "BuildGrain") -> "BuildGrain":
-        return BuildGrain(
+        return BuildGrain.model_construct(
             components=self.components.difference(other.components),
             where_clause=self.where_clause,
         )
@@ -637,9 +634,6 @@ class BuildComparison(BuildConceptArgs, ConstantInlineable, BaseModel):
     ]
     operator: ComparisonOperator
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-
     def __add__(self, other):
         if other is None:
             return self
@@ -1173,7 +1167,7 @@ class BuildAggregateWrapper(BuildConceptArgs, DataTyped, BaseModel):
 
 
 class BuildFilterItem(BuildConceptArgs, BaseModel):
-    content: BuildConcept
+    content: "BuildExpr"
     where: BuildWhereClause
 
     def __str__(self):
@@ -1181,15 +1175,27 @@ class BuildFilterItem(BuildConceptArgs, BaseModel):
 
     @property
     def output_datatype(self):
-        return self.content.datatype
+        return arg_to_datatype(self.content)
 
     @property
     def output_purpose(self):
         return self.content.purpose
 
+    @property
+    def content_concept_arguments(self):
+        if isinstance(self.content, BuildConcept):
+            return [self.content]
+        elif isinstance(self.content, BuildConceptArgs):
+            return self.content.concept_arguments
+        return []
+
     @property
     def concept_arguments(self):
-        return [self.content] + self.where.concept_arguments
+        if isinstance(self.content, BuildConcept):
+            return [self.content] + self.where.concept_arguments
+        elif isinstance(self.content, BuildConceptArgs):
+            return self.content.concept_arguments + self.where.concept_arguments
+        return self.where.concept_arguments
 
 
 class BuildRowsetLineage(BuildConceptArgs, BaseModel):

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/models/execute.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Dict, List, Optional, Set, Union
-
-from pydantic import BaseModel, Field, ValidationInfo, computed_field, field_validator
+from typing import Dict, List, Optional, Set, Union
+
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationInfo,
+    computed_field,
+    field_validator,
+    model_validator,
+)
 
 from trilogy.constants import CONFIG, logger
 from trilogy.core.constants import CONSTANT_DATASET
@@ -473,8 +480,8 @@ class BaseJoin(BaseModel):
     left_datasource: Optional[Union[BuildDatasource, "QueryDatasource"]] = None
     concept_pairs: list[ConceptPair] | None = None
 
-    def __init__(self, **data: Any):
-        super().__init__(**data)
+    @model_validator(mode="after")
+    def validate_join(self) -> "BaseJoin":
         if (
             self.left_datasource
             and self.left_datasource.identifier == self.right_datasource.identifier
@@ -483,14 +490,18 @@ class BaseJoin(BaseModel):
                 f"Cannot join a dataself to itself, joining {self.left_datasource} and"
                 f" {self.right_datasource}"
             )
-        final_concepts = []
 
-        # if we have a list of concept pairs
+        # Early returns maintained as in original code
         if self.concept_pairs:
-            return
+            return self
+
         if self.concepts == []:
-            return
+            return self
+
+        # Validation logic
+        final_concepts = []
         assert self.left_datasource and self.right_datasource
+
         for concept in self.concepts or []:
             include = True
             for ds in [self.left_datasource, self.right_datasource]:
@@ -507,6 +518,7 @@ class BaseJoin(BaseModel):
                     )
             if include:
                 final_concepts.append(concept)
+
         if not final_concepts and self.concepts:
             # if one datasource only has constants
             # we can join on 1=1
@@ -519,11 +531,11 @@ class BaseJoin(BaseModel):
                     ]
                 ):
                     self.concepts = []
-                    return
+                    return self
                 # if everything is at abstract grain, we can skip joins
                 if all([c.grain.abstract for c in ds.output_concepts]):
                     self.concepts = []
-                    return
+                    return self
 
             left_keys = [c.address for c in self.left_datasource.output_concepts]
             right_keys = [c.address for c in self.right_datasource.output_concepts]
@@ -535,7 +547,9 @@ class BaseJoin(BaseModel):
                 f" right_keys {right_keys},"
                 f" provided join concepts {match_concepts}"
             )
+
         self.concepts = final_concepts
+        return self
 
     @property
     def unique_id(self) -> str:
@@ -695,7 +709,7 @@ class QueryDatasource(BaseModel):
                 "can only merge two datasources if the force_group flag is the same"
             )
         logger.debug(
-            f"{LOGGER_PREFIX} merging {self.name} with"
+            f"[Query Datasource] merging {self.name} with"
             f" {[c.address for c in self.output_concepts]} concepts and"
             f" {other.name} with {[c.address for c in other.output_concepts]} concepts"
         )
@@ -759,7 +773,9 @@ class QueryDatasource(BaseModel):
             hidden_concepts=hidden,
             ordering=self.ordering,
         )
-
+        logger.debug(
+            f"[Query Datasource] merged with {[c.address for c in qds.output_concepts]} concepts"
+        )
         return qds
 
     @property

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/processing/concept_strategies_v3.py

@@ -319,7 +319,7 @@ def generate_node(
         ]
 
         logger.info(
-            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating aggregate node with {[x.address for x in agg_optional]}"
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating aggregate node with {[x for x in agg_optional]}"
         )
         return gen_group_node(
             concept,

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.52}/trilogy/core/processing/node_generators/common.py

@@ -67,14 +67,14 @@ def resolve_condition_parent_concepts(
 def resolve_filter_parent_concepts(
     concept: BuildConcept,
     environment: BuildEnvironment,
-) -> Tuple[BuildConcept, List[BuildConcept], List[Tuple[BuildConcept, ...]]]:
+) -> Tuple[List[BuildConcept], List[Tuple[BuildConcept, ...]]]:
     if not isinstance(concept.lineage, (BuildFilterItem,)):
         raise ValueError(
             f"Concept {concept} lineage is not filter item, is {type(concept.lineage)}"
         )
     direct_parent = concept.lineage.content
     base_existence = []
-    base_rows = [direct_parent]
+    base_rows = [direct_parent] if isinstance(direct_parent, BuildConcept) else []
     condition_rows, condition_existence = resolve_condition_parent_concepts(
         concept.lineage.where
     )
@@ -90,11 +90,10 @@ def resolve_filter_parent_concepts(
 
     if concept.lineage.where.existence_arguments:
         return (
-            concept.lineage.content,
             unique(base_rows, "address"),
             base_existence,
         )
-    return concept.lineage.content, unique(base_rows, "address"), []
+    return unique(base_rows, "address"), []
 
 
 def gen_property_enrichment_node(