pytrilogy 0.0.3.92__tar.gz → 0.0.3.94__tar.gz

{pytrilogy-0.0.3.92/pytrilogy.egg-info → pytrilogy-0.0.3.94}/PKG-INFO

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

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94}/tests/test_discovery_nodes.py

@@ -67,7 +67,7 @@ def test_group_node_property_all(test_environment: Environment, test_environment
     sum_name_length = test_environment.concepts["category_name_length_sum"]
     all_rows = test_environment.concepts[f"{INTERNAL_NAMESPACE}.{ALL_ROWS_CONCEPT}"]
     sum_name_length_all_rows = sum_name_length.with_grain(
-        BuildGrain(components=[all_rows])
+        BuildGrain(components={all_rows.address})
     )
     group_node = gen_group_node(
         sum_name_length_all_rows,

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94}/tests/test_parsing.py

@@ -5,7 +5,6 @@ from trilogy.core.functions import argument_to_purpose, function_args_to_output_
 from trilogy.core.models.author import (
     Comparison,
     Conditional,
-    ListWrapper,
     SubselectComparison,
 )
 from trilogy.core.models.build import BuildComparison
@@ -61,7 +60,7 @@ def test_not_in():
     _, parsed = parse_text(
         "const order_id <- 4; SELECT order_id  WHERE order_id NOT IN (1,2,3);"
     )
-    query: ProcessedQuery = parsed[-1]
+    query: SelectStatement = parsed[-1]
     right = query.where_clause.conditional.right
     assert isinstance(right, TupleWrapper), type(right)
     assert right[0] == 1
@@ -75,7 +74,7 @@ def test_datetime_lit_rendering():
     from datetime import datetime
 
     now = datetime.now()
-    wrapper = ListWrapper(
+    wrapper = TupleWrapper(
         (now,),
         type=DataType.DATETIME,
     )

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94}/tests/test_query_processing.py

@@ -135,7 +135,7 @@ def test_basic_aggregate(test_environment: Environment, test_environment_graph):
     )
     datasource = datasource.resolve()
     assert isinstance(datasource, QueryDatasource)
-    assert datasource.grain == BuildGrain(components=[product])
+    assert datasource.grain == BuildGrain(components={product.address})
 
 
 def test_join_aggregate(test_environment: Environment, test_environment_graph):

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94}/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.92"
+__version__ = "0.0.3.94"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94}/trilogy/core/env_processor.py

@@ -44,8 +44,10 @@ def add_concept(
             continue
         if pseudonym_node.split("@")[0] == node_name.split("@")[0]:
             continue
-        g.add_edge(pseudonym_node, node_name, pseudonym=True)
-        g.add_edge(node_name, pseudonym_node, pseudonym=True)
+        g.add_edge(pseudonym_node, node_name)
+        g.add_edge(node_name, pseudonym_node)
+        g.pseudonyms.add((pseudonym_node, node_name))
+        g.pseudonyms.add((node_name, pseudonym_node))
         add_concept(pseudonym, g, concept_mapping, default_concept_graph, seen)
 
 

pytrilogy-0.0.3.94/trilogy/core/graph_models.py

@@ -0,0 +1,132 @@
+from typing import Union
+
+import networkx as nx
+
+from trilogy.core.models.build import BuildConcept, BuildDatasource, BuildWhereClause
+
+
+def get_graph_exact_match(
+    g: Union[nx.DiGraph, "ReferenceGraph"],
+    accept_partial: bool,
+    conditions: BuildWhereClause | None,
+) -> set[str]:
+    exact: set[str] = set()
+    for node, ds in g.datasources.items():
+        if isinstance(ds, list):
+            exact.add(node)
+            continue
+
+        if not conditions and not ds.non_partial_for:
+            exact.add(node)
+            continue
+        elif not conditions and accept_partial and ds.non_partial_for:
+            exact.add(node)
+            continue
+        elif conditions:
+            if not ds.non_partial_for:
+                continue
+            if ds.non_partial_for and conditions == ds.non_partial_for:
+                exact.add(node)
+                continue
+        else:
+            continue
+
+    return exact
+
+
+def prune_sources_for_conditions(
+    g: "ReferenceGraph",
+    accept_partial: bool,
+    conditions: BuildWhereClause | None,
+):
+    complete = get_graph_exact_match(g, accept_partial, conditions)
+    to_remove = []
+    for node in g.datasources:
+        if node not in complete:
+            to_remove.append(node)
+
+    for node in to_remove:
+        g.remove_node(node)
+
+
+def concept_to_node(input: BuildConcept) -> str:
+    # if input.purpose == Purpose.METRIC:
+    #     return f"c~{input.namespace}.{input.name}@{input.grain}"
+    return f"c~{input.address}@{input.grain.str_no_condition}"
+
+
+def datasource_to_node(input: BuildDatasource) -> str:
+    # if isinstance(input, JoinedDataSource):
+    #     return "ds~join~" + ",".join(
+    #         [datasource_to_node(sub) for sub in input.datasources]
+    #     )
+    return f"ds~{input.identifier}"
+
+
+class ReferenceGraph(nx.DiGraph):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.concepts: dict[str, BuildConcept] = {}
+        self.datasources: dict[str, BuildDatasource] = {}
+        self.pseudonyms: set[tuple[str, str]] = set()
+
+    def copy(self):
+        g = ReferenceGraph()
+        g.concepts = self.concepts.copy()
+        g.datasources = self.datasources.copy()
+        g.pseudonyms = {*self.pseudonyms}
+        # g.add_nodes_from(self.nodes(data=True))
+        for node in self.nodes:
+            g.add_node(node, fast=True)
+        for edge in self.edges:
+            g.add_edge(edge[0], edge[1], fast=True)
+        # g.add_edges_from(self.edges(data=True))
+        return g
+
+    def remove_node(self, n):
+        if n in self.concepts:
+            del self.concepts[n]
+        if n in self.datasources:
+            del self.datasources[n]
+        super().remove_node(n)
+
+    def add_node(self, node_for_adding, fast: bool = False, **attr):
+        if fast:
+            return super().add_node(node_for_adding, **attr)
+        if isinstance(node_for_adding, BuildConcept):
+            node_name = concept_to_node(node_for_adding)
+            self.concepts[node_name] = node_for_adding
+        elif isinstance(node_for_adding, BuildDatasource):
+            node_name = datasource_to_node(node_for_adding)
+            self.datasources[node_name] = node_for_adding
+        else:
+            node_name = node_for_adding
+            if attr.get("datasource"):
+                self.datasources[node_name] = attr["datasource"]
+        super().add_node(node_name, **attr)
+
+    def add_edge(self, u_of_edge, v_of_edge, fast: bool = False, **attr):
+        if fast:
+            return super().add_edge(u_of_edge, v_of_edge, **attr)
+        if isinstance(u_of_edge, BuildConcept):
+            orig = u_of_edge
+            u_of_edge = concept_to_node(u_of_edge)
+            if u_of_edge not in self.nodes:
+                self.add_node(orig)
+        elif isinstance(u_of_edge, BuildDatasource):
+            origd = u_of_edge
+            u_of_edge = datasource_to_node(u_of_edge)
+            if u_of_edge not in self.nodes:
+                self.add_node(origd)
+
+        if isinstance(v_of_edge, BuildConcept):
+            orig = v_of_edge
+            v_of_edge = concept_to_node(v_of_edge)
+            if v_of_edge not in self.nodes:
+                self.add_node(orig)
+        elif isinstance(v_of_edge, BuildDatasource):
+            origd = v_of_edge
+            v_of_edge = datasource_to_node(v_of_edge)
+            if v_of_edge not in self.nodes:
+                self.add_node(origd)
+        super().add_edge(u_of_edge, v_of_edge)

{pytrilogy-0.0.3.92 → pytrilogy-0.0.3.94}/trilogy/core/models/author.py

@@ -902,7 +902,11 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
 
     @property
     def is_aggregate(self):
-        return self.calculate_is_aggregate(self.lineage)
+        base = getattr(self, "_is_aggregate", None)
+        if base:
+            return base
+        setattr(self, "_is_aggregate", self.calculate_is_aggregate(self.lineage))
+        return self._is_aggregate
 
     def with_merge(self, source: Self, target: Self, modifiers: List[Modifier]) -> Self:
         if self.address == source.address:
@@ -1069,18 +1073,25 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         final_grain = grain if not self.grain.components else self.grain
         keys = self.keys
 
-        if self.is_aggregate and isinstance(new_lineage, Function) and grain.components:
+        if self.is_aggregate and grain.components and isinstance(new_lineage, Function):
             grain_components: list[ConceptRef | Concept] = [
                 environment.concepts[c].reference for c in grain.components
             ]
-            new_lineage = AggregateWrapper(function=new_lineage, by=grain_components)
+            new_lineage = AggregateWrapper.model_construct(
+                function=new_lineage, by=grain_components
+            )
             final_grain = grain
             keys = set(grain.components)
-        elif isinstance(new_lineage, AggregateWrapper) and not new_lineage.by and grain:
+        elif (
+            grain
+            and new_lineage
+            and isinstance(new_lineage, AggregateWrapper)
+            and not new_lineage.by
+        ):
             grain_components = [
                 environment.concepts[c].reference for c in grain.components
             ]
-            new_lineage = AggregateWrapper(
+            new_lineage = AggregateWrapper.model_construct(
                 function=new_lineage.function, by=grain_components
             )
             final_grain = grain
@@ -1133,7 +1144,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
             granularity=self.granularity,
             derivation=self.derivation,
             lineage=self.lineage,
-            grain=grain if grain else Grain(components=set()),
+            grain=grain if grain else Grain.model_construct(components=set()),
             namespace=self.namespace,
             keys=self.keys,
             modifiers=self.modifiers,
@@ -1670,15 +1681,6 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     def datatype(self):
         return self.output_datatype
 
-    @field_validator("output_datatype")
-    @classmethod
-    def parse_output_datatype(cls, v, info: ValidationInfo):
-        values = info.data
-        if values.get("operator") == FunctionType.ATTR_ACCESS:
-            if isinstance(v, StructType):
-                raise SyntaxError
-        return v
-
     @field_validator("arguments", mode="before")
     @classmethod
     def parse_arguments(cls, v, info: ValidationInfo):
@@ -1845,17 +1847,6 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
             base += get_concept_arguments(arg)
         return base
 
-    @property
-    def output_grain(self):
-        # aggregates have an abstract grain
-        base_grain = Grain(components=[])
-        if self.operator in FunctionClass.AGGREGATE_FUNCTIONS.value:
-            return base_grain
-        # scalars have implicit grain of all arguments
-        for input in self.concept_arguments:
-            base_grain += input.grain
-        return base_grain
-
 
 class FunctionCallWrapper(
     DataTyped,