pytrilogy 0.0.3.64__tar.gz → 0.0.3.66__tar.gz

{pytrilogy-0.0.3.64/pytrilogy.egg-info → pytrilogy-0.0.3.66}/PKG-INFO

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

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/tests/test_parsing.py

@@ -2,7 +2,7 @@ from trilogy import Dialects
 from trilogy.constants import MagicConstants
 from trilogy.core.enums import BooleanOperator, ComparisonOperator, Purpose
 from trilogy.core.functions import argument_to_purpose, function_args_to_output_purpose
-from trilogy.core.models.author import Comparison
+from trilogy.core.models.author import Comparison, Conditional, SubselectComparison
 from trilogy.core.models.core import (
     DataType,
     TupleWrapper,
@@ -16,6 +16,7 @@ from trilogy.core.models.environment import (
 from trilogy.core.statements.author import SelectStatement, ShowStatement
 from trilogy.core.statements.execute import ProcessedQuery
 from trilogy.dialect.base import BaseDialect
+from trilogy.parsing.common import atom_is_relevant
 from trilogy.parsing.parse_engine import (
     arg_to_datatype,
     parse_text,
@@ -685,3 +686,45 @@ select x % 10 -> x_mod_10;
             
 """
     )
+
+
+def test_is_atom():
+    env = Environment()
+
+    env.parse(
+        """
+key x int;
+auto x_sum <- sum(x);
+"""
+    )
+
+    assert not atom_is_relevant(
+        Comparison(left=env.concepts["x_sum"], right=0, operator=ComparisonOperator.GT),
+        [env.concepts["x"]],
+        env,
+    )
+    assert atom_is_relevant(
+        Comparison(left=env.concepts["x"], right=0, operator=ComparisonOperator.GT),
+        [env.concepts["x_sum"]],
+        env,
+    )
+
+    assert not atom_is_relevant(
+        Conditional(left=env.concepts["x_sum"], right=0, operator=BooleanOperator.AND),
+        [env.concepts["x"]],
+        env,
+    )
+    assert atom_is_relevant(
+        Conditional(left=env.concepts["x"], right=0, operator=BooleanOperator.AND),
+        [env.concepts["x_sum"]],
+        env,
+    )
+    assert not atom_is_relevant(
+        SubselectComparison(
+            left=env.concepts["x_sum"],
+            right=env.concepts["x"],
+            operator=ComparisonOperator.IN,
+        ),
+        [env.concepts["x_sum"]],
+        env,
+    )

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

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/graph_models.py

@@ -1,6 +1,50 @@
 import networkx as nx
 
-from trilogy.core.models.build import BuildConcept, BuildDatasource
+from trilogy.core.models.build import BuildConcept, BuildDatasource, BuildWhereClause
+
+
+def get_graph_exact_match(
+    g: nx.DiGraph, conditions: BuildWhereClause | None
+) -> set[str]:
+    datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
+        nx.get_node_attributes(g, "datasource")
+    )
+    exact: set[str] = set()
+    for node in g.nodes:
+        if node in datasources:
+            ds = datasources[node]
+            if isinstance(ds, list):
+                exact.add(node)
+                continue
+
+            if not conditions and not 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: nx.DiGraph,
+    conditions: BuildWhereClause | None,
+):
+
+    complete = get_graph_exact_match(g, conditions)
+    to_remove = []
+    for node in g.nodes:
+        if node.startswith("ds~") and node not in complete:
+            to_remove.append(node)
+
+    for node in to_remove:
+        g.remove_node(node)
 
 
 def concept_to_node(input: BuildConcept) -> str:

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/models/author.py

@@ -271,6 +271,20 @@ class Conditional(Mergeable, ConceptArgs, Namespaced, DataTyped, BaseModel):
     right: Expr
     operator: BooleanOperator
 
+    @field_validator("left", mode="before")
+    @classmethod
+    def left_validator(cls, v, info: ValidationInfo):
+        if isinstance(v, Concept):
+            return v.reference
+        return v
+
+    @field_validator("right", mode="before")
+    @classmethod
+    def right_validator(cls, v, info: ValidationInfo):
+        if isinstance(v, Concept):
+            return v.reference
+        return v
+
     def __add__(self, other) -> "Conditional":
         if other is None:
             return self
@@ -346,7 +360,6 @@ class Conditional(Mergeable, ConceptArgs, Namespaced, DataTyped, BaseModel):
 
     @property
     def concept_arguments(self) -> Sequence[ConceptRef]:
-        """Return concepts directly referenced in where clause"""
         output = []
         output += get_concept_arguments(self.left)
         output += get_concept_arguments(self.right)
@@ -575,11 +588,11 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
         date,
         Function,
         ConceptRef,
-        "Conditional",
+        Conditional,
         DataType,
-        "Comparison",
+        Comparison,
         FunctionCallWrapper,
-        "Parenthetical",
+        Parenthetical,
         MagicConstants,
         WindowItem,
         AggregateWrapper,

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/models/build.py

@@ -1631,7 +1631,10 @@ class Factory:
 
     @build.register
     def _(self, base: CaseElse) -> BuildCaseElse:
-        return BuildCaseElse.model_construct(expr=self.build(base.expr))
+        expr: Concept | FuncArgs = base.expr
+        if isinstance(expr, (AggregateWrapper, FilterItem, WindowItem)):
+            expr, _ = self.instantiate_concept(expr)
+        return BuildCaseElse.model_construct(expr=self.build(expr))
 
     @build.register
     def _(self, base: Concept) -> BuildConcept:

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/models/environment.py

@@ -603,7 +603,7 @@ class Environment(BaseModel):
             # too hacky for maintainability
             if current_derivation not in (Derivation.ROOT, Derivation.CONSTANT):
                 logger.info(
-                    f"A datasource has been added which will persist derived concept {new_persisted_concept.address}"
+                    f"A datasource has been added which will persist derived concept {new_persisted_concept.address} with derivation {current_derivation}"
                 )
                 persisted = f"{PERSISTED_CONCEPT_PREFIX}_" + new_persisted_concept.name
                 # override the current concept source to reflect that it's now coming from a datasource
@@ -622,17 +622,21 @@ class Environment(BaseModel):
                         meta=meta,
                         force=True,
                     )
+                    base = {
+                        "lineage": None,
+                        "metadata": new_persisted_concept.metadata.model_copy(
+                            update={"concept_source": ConceptSource.PERSIST_STATEMENT}
+                        ),
+                        "derivation": Derivation.ROOT,
+                        "purpose": new_persisted_concept.purpose,
+                    }
+                    # purpose is used in derivation calculation
+                    # which should be fixed, but we'll do in a followup
+                    # so override here
+                    if new_persisted_concept.purpose == Purpose.CONSTANT:
+                        base["purpose"] = Purpose.KEY
                     new_persisted_concept = new_persisted_concept.model_copy(
-                        deep=True,
-                        update={
-                            "lineage": None,
-                            "metadata": new_persisted_concept.metadata.model_copy(
-                                update={
-                                    "concept_source": ConceptSource.PERSIST_STATEMENT
-                                }
-                            ),
-                            "derivation": Derivation.ROOT,
-                        },
+                        deep=True, update=base
                     )
                     self.add_concept(
                         new_persisted_concept,

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/models/execute.py

@@ -56,6 +56,12 @@ LOGGER_PREFIX = "[MODELS_EXECUTE]"
 DATASOURCE_TYPES = (BuildDatasource, BuildDatasource)
 
 
+class InlinedCTE(BaseModel):
+    original_alias: str
+    new_alias: str
+    new_base: str
+
+
 class CTE(BaseModel):
     name: str
     source: "QueryDatasource"
@@ -78,6 +84,7 @@ class CTE(BaseModel):
     limit: Optional[int] = None
     base_name_override: Optional[str] = None
     base_alias_override: Optional[str] = None
+    inlined_ctes: dict[str, InlinedCTE] = Field(default_factory=dict)
 
     @field_validator("join_derived_concepts")
     def validate_join_derived_concepts(cls, v):
@@ -104,62 +111,6 @@ class CTE(BaseModel):
     def validate_output_columns(cls, v):
         return unique(v, "address")
 
-    def inline_constant(self, concept: BuildConcept):
-        if not concept.derivation == Derivation.CONSTANT:
-            return False
-        if not isinstance(concept.lineage, BuildFunction):
-            return False
-        if not concept.lineage.operator == FunctionType.CONSTANT:
-            return False
-        # remove the constant
-        removed: set = set()
-        if concept.address in self.source_map:
-            removed = removed.union(self.source_map[concept.address])
-            del self.source_map[concept.address]
-
-        if self.condition:
-            self.condition = self.condition.inline_constant(concept)
-        # if we've entirely removed the need to join to someplace to get the concept
-        # drop the join as well.
-        for removed_cte in removed:
-            still_required = any(
-                [
-                    removed_cte in x
-                    for x in self.source_map.values()
-                    or self.existence_source_map.values()
-                ]
-            )
-            if not still_required:
-                self.joins = [
-                    join
-                    for join in self.joins
-                    if not isinstance(join, Join)
-                    or (
-                        isinstance(join, Join)
-                        and (
-                            join.right_cte.name != removed_cte
-                            and any(
-                                [
-                                    x.cte.name != removed_cte
-                                    for x in (join.joinkey_pairs or [])
-                                ]
-                            )
-                        )
-                    )
-                ]
-                for join in self.joins:
-                    if isinstance(join, UnnestJoin) and concept in join.concepts:
-                        join.rendering_required = False
-
-                self.parent_ctes = [
-                    x for x in self.parent_ctes if x.name != removed_cte
-                ]
-                if removed_cte == self.base_name_override:
-                    candidates = [x.name for x in self.parent_ctes]
-                    self.base_name_override = candidates[0] if candidates else None
-                    self.base_alias_override = candidates[0] if candidates else None
-        return True
-
     @property
     def comment(self) -> str:
         base = f"Target: {str(self.grain)}. Group: {self.group_to_grain}"
@@ -240,7 +191,18 @@ class CTE(BaseModel):
                 ]
             elif v == parent.safe_identifier:
                 self.source_map[k] = [ds_being_inlined.safe_identifier]
-
+        for k, v in self.existence_source_map.items():
+            if isinstance(v, list):
+                self.existence_source_map[k] = [
+                    (
+                        ds_being_inlined.safe_identifier
+                        if x == parent.safe_identifier
+                        else x
+                    )
+                    for x in v
+                ]
+            elif v == parent.safe_identifier:
+                self.existence_source_map[k] = [ds_being_inlined.safe_identifier]
         # zip in any required values for lookups
         for k in ds_being_inlined.output_lcl.addresses:
             if k in self.source_map and self.source_map[k]:
@@ -251,6 +213,11 @@ class CTE(BaseModel):
         ]
         if force_group:
             self.group_to_grain = True
+        self.inlined_ctes[ds_being_inlined.safe_identifier] = InlinedCTE(
+            original_alias=parent.name,
+            new_alias=ds_being_inlined.safe_identifier,
+            new_base=ds_being_inlined.safe_location,
+        )
         return True
 
     def __add__(self, other: "CTE" | "UnionCTE"):
@@ -303,6 +270,10 @@ class CTE(BaseModel):
             **self.existence_source_map,
             **other.existence_source_map,
         }
+        self.inlined_ctes = {
+            **self.inlined_ctes,
+            **other.inlined_ctes,
+        }
 
         return self
 
@@ -672,7 +643,7 @@ class QueryDatasource(BaseModel):
                     and CONFIG.validate_missing
                 ):
                     raise SyntaxError(
-                        f"On query datasource from {values} missing source map entry (map: {v}) for {concept.address} on {key} with pseudonyms {concept.pseudonyms}, have {v}"
+                        f"Missing source map entry for {concept.address} on {key} with pseudonyms {concept.pseudonyms}, have map: {v}"
                     )
         return v
 
@@ -1057,6 +1028,7 @@ class UnionCTE(BaseModel):
     hidden_concepts: set[str] = Field(default_factory=set)
     partial_concepts: list[BuildConcept] = Field(default_factory=list)
     existence_source_map: Dict[str, list[str]] = Field(default_factory=dict)
+    inlined_ctes: Dict[str, InlinedCTE] = Field(default_factory=dict)
 
     @computed_field  # type: ignore
     @property

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/processing/node_generators/node_merge_node.py

@@ -6,7 +6,7 @@ from networkx.algorithms import approximation as ax
 from trilogy.constants import logger
 from trilogy.core.enums import Derivation
 from trilogy.core.exceptions import AmbiguousRelationshipResolutionException
-from trilogy.core.graph_models import concept_to_node
+from trilogy.core.graph_models import concept_to_node, prune_sources_for_conditions
 from trilogy.core.models.build import BuildConcept, BuildConditional, BuildWhereClause
 from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.processing.nodes import History, MergeNode, StrategyNode
@@ -222,10 +222,12 @@ def resolve_weak_components(
     environment_graph: nx.DiGraph,
     filter_downstream: bool = True,
     accept_partial: bool = False,
+    search_conditions: BuildWhereClause | None = None,
 ) -> list[list[BuildConcept]] | None:
     break_flag = False
     found = []
     search_graph = environment_graph.copy()
+    prune_sources_for_conditions(search_graph, conditions=search_conditions)
     reduced_concept_sets: list[set[str]] = []
 
     # loop through, removing new nodes we find
@@ -406,6 +408,7 @@ def gen_merge_node(
             g,
             filter_downstream=filter_downstream,
             accept_partial=accept_partial,
+            search_conditions=search_conditions,
         )
         if not weak_resolve:
             logger.info(

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/processing/node_generators/select_helpers/datasource_injection.py

@@ -169,7 +169,9 @@ def is_fully_covered(
     return current_end >= end
 
 
-def get_union_sources(datasources: list[BuildDatasource], concepts: list[BuildConcept]):
+def get_union_sources(
+    datasources: list[BuildDatasource], concepts: list[BuildConcept]
+) -> List[list[BuildDatasource]]:
     candidates: list[BuildDatasource] = []
     for x in datasources:
         if all([c.address in x.output_concepts for c in concepts]):

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -5,7 +5,11 @@ import networkx as nx
 
 from trilogy.constants import logger
 from trilogy.core.enums import Derivation
-from trilogy.core.graph_models import concept_to_node
+from trilogy.core.graph_models import (
+    concept_to_node,
+    get_graph_exact_match,
+    prune_sources_for_conditions,
+)
 from trilogy.core.models.build import (
     BuildConcept,
     BuildDatasource,
@@ -57,28 +61,6 @@ def get_graph_partial_nodes(
     return partial
 
 
-def get_graph_exact_match(
-    g: nx.DiGraph, conditions: BuildWhereClause | None
-) -> set[str]:
-    datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
-        nx.get_node_attributes(g, "datasource")
-    )
-    exact: set[str] = set()
-    for node in g.nodes:
-        if node in datasources:
-            ds = datasources[node]
-            if not isinstance(ds, list):
-                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 get_graph_grains(g: nx.DiGraph) -> dict[str, list[str]]:
     datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
         nx.get_node_attributes(g, "datasource")
@@ -98,28 +80,31 @@ def get_graph_grains(g: nx.DiGraph) -> dict[str, list[str]]:
 
 
 def subgraph_is_complete(
-    nodes: list[str], targets: set[str], mapping: dict[str, str]
+    nodes: list[str], targets: set[str], mapping: dict[str, str], g: nx.DiGraph
 ) -> bool:
     mapped = set([mapping.get(n, n) for n in nodes])
-    return all([t in mapped for t in targets])
-
-
-def prune_sources_for_conditions(
-    g: nx.DiGraph,
-    depth: int,
-    conditions: BuildWhereClause | None,
-):
-
-    complete = get_graph_exact_match(g, conditions)
-    to_remove = []
-    for node in g.nodes:
-        if node.startswith("ds~") and node not in complete:
-            to_remove.append(node)
-            logger.debug(
-                f"{padding(depth)}{LOGGER_PREFIX} removing datasource {node} as it is not a match for conditions {conditions}"
-            )
-    for node in to_remove:
-        g.remove_node(node)
+    passed = all([t in mapped for t in targets])
+    if not passed:
+        logger.info(
+            f"Subgraph {nodes} is not complete, missing targets {targets} - mapped {mapped}"
+        )
+        return False
+    # check if all concepts have a datasource edge
+    has_ds_edge = {
+        mapping.get(n, n): any(x.startswith("ds~") for x in nx.neighbors(g, n))
+        for n in nodes
+        if n.startswith("c~")
+    }
+    has_ds_edge = {k: False for k in targets}
+    # check at least one instance of concept has a datasource edge
+    for n in nodes:
+        if n.startswith("c~"):
+            neighbors = nx.neighbors(g, n)
+            for neighbor in neighbors:
+                if neighbor.startswith("ds~"):
+                    has_ds_edge[mapping.get(n, n)] = True
+                    break
+    return all(has_ds_edge.values()) and passed
 
 
 def create_pruned_concept_graph(
@@ -133,8 +118,6 @@ def create_pruned_concept_graph(
     orig_g = g
 
     g = g.copy()
-    if conditions:
-        prune_sources_for_conditions(g, depth, conditions)
     union_options = get_union_sources(datasources, all_concepts)
     for ds_list in union_options:
         node_address = "ds~" + "-".join([x.name for x in ds_list])
@@ -144,7 +127,8 @@ def create_pruned_concept_graph(
         g.add_node(node_address, datasource=ds_list)
         for c in common:
             g.add_edge(node_address, concept_to_node(c))
-
+            g.add_edge(concept_to_node(c), node_address)
+    prune_sources_for_conditions(g, conditions)
     target_addresses = set([c.address for c in all_concepts])
     concepts: dict[str, BuildConcept] = nx.get_node_attributes(orig_g, "concept")
     datasource_map: dict[str, BuildDatasource | list[BuildDatasource]] = (
@@ -156,8 +140,7 @@ def create_pruned_concept_graph(
         # filter out synonyms
         if (x := concepts.get(n, None)) and x.address in target_addresses
     }
-    # from trilogy.hooks.graph_hook import GraphHook
-    # GraphHook().query_graph_built(g)
+
     relevant_concepts: list[str] = list(relevant_concepts_pre.keys())
     relevent_datasets: list[str] = []
     if not accept_partial:
@@ -179,6 +162,7 @@ def create_pruned_concept_graph(
                 to_remove.append(edge)
         for edge in to_remove:
             g.remove_edge(*edge)
+
     for n in g.nodes():
         if not n.startswith("ds~"):
             continue
@@ -211,13 +195,13 @@ def create_pruned_concept_graph(
             if n not in relevent_datasets and n not in relevant_concepts
         ]
     )
-
+    # from trilogy.hooks.graph_hook import GraphHook
+    # GraphHook().query_graph_built(g)
     subgraphs = list(nx.connected_components(g.to_undirected()))
-
     subgraphs = [
         s
         for s in subgraphs
-        if subgraph_is_complete(s, target_addresses, relevant_concepts_pre)
+        if subgraph_is_complete(s, target_addresses, relevant_concepts_pre, g)
     ]
 
     if not subgraphs:
@@ -524,8 +508,12 @@ def gen_select_merge_node(
     constants = [c for c in all_concepts if c.derivation == Derivation.CONSTANT]
     if not non_constant and constants:
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} only constant inputs to discovery, returning constant node directly"
+            f"{padding(depth)}{LOGGER_PREFIX} only constant inputs to discovery ({constants}), returning constant node directly"
         )
+        for x in constants:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} {x} {x.lineage} {x.derivation}"
+            )
         if conditions:
             if not all(
                 [x.derivation == Derivation.CONSTANT for x in conditions.row_arguments]

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/core/query_processor.py

@@ -395,6 +395,9 @@ def get_query_node(
     if not statement.output_components:
         raise ValueError(f"Statement has no output components {statement}")
     history = history or History(base_environment=environment)
+    print(
+        f"{LOGGER_PREFIX} building query node for {statement.output_components} grain {statement.grain}"
+    )
     build_statement: BuildSelectLineage | BuildMultiSelectLineage = Factory(
         environment=environment,
     ).build(statement)

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/dialect/base.py

@@ -580,7 +580,12 @@ class BaseDialect:
                     target = INVALID_REFERENCE_STRING(
                         f"Missing source CTE for {e.right.address}"
                     )
+                assert cte, "CTE must be provided for inlined CTEs"
+                if target in cte.inlined_ctes:
+                    info = cte.inlined_ctes[target]
+                    return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} {e.operator.value} (select {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {info.new_base} as {target} where {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} is not null)"
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} {e.operator.value} (select {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {target} where {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} is not null)"
+
             elif isinstance(
                 e.right,
                 (ListWrapper, TupleWrapper, BuildParenthetical, list),

{pytrilogy-0.0.3.64 → pytrilogy-0.0.3.66}/trilogy/hooks/graph_hook.py

@@ -85,7 +85,6 @@ class GraphHook(BaseHook):
         plt.show()
 
     def _draw_labels_with_manual_spacing(self, graph, pos):
-        """Fallback method for manual label spacing when adjustText is not available"""
         import numpy as np
 
         pos_labels = {}