pytrilogy 0.0.2.42__tar.gz → 0.0.2.44__tar.gz

{pytrilogy-0.0.2.42/pytrilogy.egg-info → pytrilogy-0.0.2.44}/PKG-INFO

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

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.2.42"
+__version__ = "0.0.2.44"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/core/exceptions.py

@@ -16,6 +16,10 @@ class NoDatasourceException(Exception):
     pass
 
 
+class FrozenEnvironmentException(Exception):
+    pass
+
+
 class AmbiguousRelationshipResolutionException(Exception):
     def __init__(self, message, parents: List[set[str]]):
         super().__init__(self, message)

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/core/models.py

@@ -67,7 +67,10 @@ from trilogy.core.enums import (
     SelectFiltering,
     IOType,
 )
-from trilogy.core.exceptions import UndefinedConceptException, InvalidSyntaxException
+from trilogy.core.exceptions import (
+    UndefinedConceptException,
+    InvalidSyntaxException,
+)
 from trilogy.utility import unique
 from collections import UserList, UserDict
 from functools import cached_property
@@ -555,6 +558,8 @@ class Concept(Mergeable, Namespaced, SelectContext, BaseModel):
             v = Grain(components=[])
         elif isinstance(v, Concept):
             v = Grain(components=[v])
+        elif isinstance(v, dict):
+            v = Grain.model_validate(v)
         if not v:
             raise SyntaxError(f"Invalid grain {v} for concept {values['name']}")
         return v
@@ -3337,7 +3342,7 @@ class EnvironmentConceptDict(dict):
 class ImportStatement(HasUUID, BaseModel):
     alias: str
     path: Path
-    environment: Union["Environment", None] = None
+    # environment: Union["Environment", None] = None
     # TODO: this might result in a lot of duplication
     # environment:"Environment"
 
@@ -3385,9 +3390,13 @@ class Environment(BaseModel):
     environment_config: EnvironmentOptions = Field(default_factory=EnvironmentOptions)
     version: str = Field(default_factory=get_version)
     cte_name_map: Dict[str, str] = Field(default_factory=dict)
-
-    materialized_concepts: List[Concept] = Field(default_factory=list)
+    materialized_concepts: set[str] = Field(default_factory=set)
     alias_origin_lookup: Dict[str, Concept] = Field(default_factory=dict)
+    # TODO: support freezing environments to avoid mutation
+    # frozen: bool = False
+
+    def duplicate(self):
+        return self.model_copy(deep=True)
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -3405,6 +3414,12 @@ class Environment(BaseModel):
         )
         self.add_concept(concept)
 
+    # def freeze(self):
+    #     self.frozen = True
+
+    # def thaw(self):
+    #     self.frozen = False
+
     @classmethod
     def from_file(cls, path: str | Path) -> "Environment":
         with open(path, "r") as f:
@@ -3435,14 +3450,17 @@ class Environment(BaseModel):
         for datasource in self.datasources.values():
             for concept in datasource.output_concepts:
                 concrete_addresses.add(concept.address)
-        self.materialized_concepts = unique(
-            [c for c in self.concepts.values() if c.address in concrete_addresses]
+        self.materialized_concepts = set(
+            [
+                c.address
+                for c in self.concepts.values()
+                if c.address in concrete_addresses
+            ]
             + [
-                c
+                c.address
                 for c in self.alias_origin_lookup.values()
                 if c.address in concrete_addresses
             ],
-            "address",
         )
 
     def validate_concept(self, new_concept: Concept, meta: Meta | None = None):
@@ -3602,7 +3620,7 @@ class Environment(BaseModel):
                     f"Unable to import file {target.parent}, parsing error: {e}"
                 )
             env = nparser.environment
-        imps = ImportStatement(alias=alias, path=target, environment=env)
+        imps = ImportStatement(alias=alias, path=target)
         self.add_import(alias, source=env, imp_stm=imps)
         return imps
 

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/core/processing/node_generators/multiselect_node.py

@@ -3,6 +3,7 @@ from trilogy.core.models import (
     Environment,
     MultiSelectStatement,
     WhereClause,
+    Conditional,
 )
 from trilogy.core.processing.nodes import MergeNode, NodeJoin, History
 from trilogy.core.processing.nodes.base_node import concept_list_to_grain, StrategyNode
@@ -14,7 +15,7 @@ from trilogy.core.processing.utility import padding
 from trilogy.core.processing.utility import concept_to_relevant_joins
 from collections import defaultdict
 from itertools import combinations
-from trilogy.core.enums import Purpose
+from trilogy.core.enums import Purpose, BooleanOperator
 from trilogy.core.processing.node_generators.common import resolve_join_order
 
 LOGGER_PREFIX = "[GEN_MULTISELECT_NODE]"
@@ -76,14 +77,22 @@ def gen_multiselect_node(
             g=g,
             depth=depth + 1,
             history=history,
+            conditions=select.where_clause,
         )
         if not snode:
             logger.info(
                 f"{padding(depth)}{LOGGER_PREFIX} Cannot generate multiselect node for {concept}"
             )
             return None
-        if select.where_clause:
-            snode.conditions = select.where_clause.conditional
+        if select.having_clause:
+            if snode.conditions:
+                snode.conditions = Conditional(
+                    left=snode.conditions,
+                    right=select.having_clause.conditional,
+                    operator=BooleanOperator.AND,
+                )
+            else:
+                snode.conditions = select.having_clause.conditional
         merge_concepts = []
         for x in [*snode.output_concepts]:
             merge = lineage.get_merge_concept(x)

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -20,6 +20,9 @@ from trilogy.core.graph_models import concept_to_node
 from trilogy.constants import logger
 from trilogy.core.processing.utility import padding
 from trilogy.core.enums import PurposeLineage
+from trilogy.core.processing.nodes.base_node import (
+    concept_list_to_grain,
+)
 
 LOGGER_PREFIX = "[GEN_ROOT_MERGE_NODE]"
 
@@ -353,7 +356,7 @@ def gen_select_merge_node(
         ]
     ):
         preexisting_conditions = conditions.conditional
-    return MergeNode(
+    base = MergeNode(
         output_concepts=all_concepts,
         input_concepts=non_constant,
         environment=environment,
@@ -362,3 +365,16 @@ def gen_select_merge_node(
         parents=parents,
         preexisting_conditions=preexisting_conditions,
     )
+    target_grain = concept_list_to_grain(all_concepts, [])
+    if not base.resolve().grain.issubset(target_grain):
+        return GroupNode(
+            output_concepts=all_concepts,
+            input_concepts=all_concepts,
+            environment=environment,
+            g=g,
+            parents=[base],
+            depth=depth,
+            preexisting_conditions=preexisting_conditions,
+            partial_concepts=base.partial_concepts,
+        )
+    return base

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/core/processing/node_generators/select_node.py

@@ -34,7 +34,7 @@ def gen_select_node(
         concepts=[
             x
             for x in all_concepts
-            if x.address in [z for z in environment.materialized_concepts]
+            if x.address in environment.materialized_concepts
             or x.derivation == PurposeLineage.CONSTANT
         ]
     )

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/dialect/base.py

@@ -348,12 +348,31 @@ class BaseDialect:
             ):
                 rval = f":{c.safe_address}"
             else:
-                args = [
-                    self.render_expr(
-                        v, cte=cte, raise_invalid=raise_invalid
-                    )  # , alias=False)
-                    for v in c.lineage.arguments
-                ]
+                args = []
+                for arg in c.lineage.arguments:
+                    if (
+                        isinstance(arg, Concept)
+                        and arg.lineage
+                        and isinstance(arg.lineage, Function)
+                        and arg.lineage.operator
+                        in (
+                            FunctionType.ADD,
+                            FunctionType.SUBTRACT,
+                            FunctionType.DIVIDE,
+                            FunctionType.MULTIPLY,
+                        )
+                    ):
+                        args.append(
+                            self.render_expr(
+                                Parenthetical(content=arg),
+                                cte=cte,
+                                raise_invalid=raise_invalid,
+                            )
+                        )
+                    else:
+                        args.append(
+                            self.render_expr(arg, cte=cte, raise_invalid=raise_invalid)
+                        )
 
                 if cte.group_to_grain:
                     rval = f"{self.FUNCTION_MAP[c.lineage.operator](args)}"
@@ -492,25 +511,39 @@ class BaseDialect:
         elif isinstance(e, CaseElse):
             return f"ELSE {self.render_expr(e.expr, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) }"
         elif isinstance(e, Function):
-
-            if cte and cte.group_to_grain:
-                return self.FUNCTION_MAP[e.operator](
-                    [
+            arguments = []
+            for arg in e.arguments:
+                if (
+                    isinstance(arg, Concept)
+                    and arg.lineage
+                    and isinstance(arg.lineage, Function)
+                    and arg.lineage.operator
+                    in (
+                        FunctionType.ADD,
+                        FunctionType.SUBTRACT,
+                        FunctionType.DIVIDE,
+                        FunctionType.MULTIPLY,
+                    )
+                ):
+                    arguments.append(
                         self.render_expr(
-                            z, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid
+                            Parenthetical(content=arg),
+                            cte=cte,
+                            cte_map=cte_map,
+                            raise_invalid=raise_invalid,
                         )
-                        for z in e.arguments
-                    ]
-                )
-
-            return self.FUNCTION_GRAIN_MATCH_MAP[e.operator](
-                [
-                    self.render_expr(
-                        z, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid
                     )
-                    for z in e.arguments
-                ]
-            )
+                else:
+                    arguments.append(
+                        self.render_expr(
+                            arg, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid
+                        )
+                    )
+
+            if cte and cte.group_to_grain:
+                return self.FUNCTION_MAP[e.operator](arguments)
+
+            return self.FUNCTION_GRAIN_MATCH_MAP[e.operator](arguments)
         elif isinstance(e, AggregateWrapper):
             return self.render_expr(
                 e.function, cte, cte_map=cte_map, raise_invalid=raise_invalid

{pytrilogy-0.0.2.42 → pytrilogy-0.0.2.44}/trilogy/parsing/parse_engine.py

@@ -907,9 +907,7 @@ class ParseToObjects(Transformer):
             except Exception as e:
                 raise ImportError(f"Unable to import file {target}, parsing error: {e}")
 
-        imps = ImportStatement(
-            alias=alias, path=Path(args[0]), environment=nparser.environment
-        )
+        imps = ImportStatement(alias=alias, path=Path(args[0]))
         self.environment.add_import(alias, nparser.environment, imps)
         return imps