pytrilogy 0.0.3.27__tar.gz → 0.0.3.28__tar.gz

{pytrilogy-0.0.3.27/pytrilogy.egg-info → pytrilogy-0.0.3.28}/PKG-INFO

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

{pytrilogy-0.0.3.27 → pytrilogy-0.0.3.28/pytrilogy.egg-info}/PKG-INFO

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

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

{pytrilogy-0.0.3.27 → pytrilogy-0.0.3.28}/trilogy/core/models/build.py

@@ -1610,8 +1610,18 @@ class Factory:
 
     @build.register
     def _(self, base: OrderItem) -> BuildOrderItem:
+        from trilogy.parsing.common import arbitrary_to_concept
+
+        bexpr: Any
+        if isinstance(base.expr, AggregateWrapper):
+            bexpr = arbitrary_to_concept(
+                base.expr,
+                environment=self.environment,
+            )
+        else:
+            bexpr = base.expr
         return BuildOrderItem.model_construct(
-            expr=(self.build(base.expr)),
+            expr=(self.build(bexpr)),
             order=base.order,
         )
 

{pytrilogy-0.0.3.27 → pytrilogy-0.0.3.28}/trilogy/core/processing/node_generators/group_node.py

@@ -86,7 +86,7 @@ def gen_group_node(
                     )
                 else:
                     logger.info(
-                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg; mismatched grain {BuildGrain.from_concepts(agg_parents)} vs {BuildGrain.from_concepts(parent_concepts)}"
+                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; mismatched grain {BuildGrain.from_concepts(agg_parents)} vs {BuildGrain.from_concepts(parent_concepts)}"
                     )
     if parent_concepts:
         logger.info(
@@ -139,7 +139,7 @@ def gen_group_node(
         )
         return group_node
     logger.info(
-        f"{padding(depth)}{LOGGER_PREFIX} group node requires enrichment, missing {missing_optional}"
+        f"{padding(depth)}{LOGGER_PREFIX} group node for {concept.address} requires enrichment, missing {missing_optional}"
     )
     return gen_enrichment_node(
         group_node,

{pytrilogy-0.0.3.27 → pytrilogy-0.0.3.28}/trilogy/core/processing/node_generators/rowset_node.py

@@ -91,7 +91,9 @@ def gen_rowset_node(
         and x.derivation != Derivation.ROWSET
         and not any(z in lineage.rowset.derived_concepts for z in x.pseudonyms)
     ]
-    logger.info(f"{padding(depth)}{LOGGER_PREFIX} hiding {final_hidden}")
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} hiding {final_hidden} local optional {local_optional}"
+    )
     node.hide_output_concepts(final_hidden)
     assert node.resolution_cache
     # assume grain to be output of select

pytrilogy-0.0.3.28/trilogy/core/processing/node_generators/window_node.py

@@ -0,0 +1,173 @@
+from typing import List
+
+from trilogy.constants import logger
+from trilogy.core.models.build import (
+    BuildConcept,
+    BuildGrain,
+    BuildWhereClause,
+    BuildWindowItem,
+)
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.processing.node_generators.common import (
+    gen_enrichment_node,
+)
+from trilogy.core.processing.nodes import History, StrategyNode, WindowNode
+from trilogy.core.processing.utility import create_log_lambda, padding
+from trilogy.utility import unique
+
+LOGGER_PREFIX = "[GEN_WINDOW_NODE]"
+
+
+WINDOW_TYPES = (BuildWindowItem,)
+
+
+def resolve_window_parent_concepts(
+    concept: BuildConcept, environment: BuildEnvironment
+) -> tuple[BuildConcept, List[BuildConcept]]:
+    if not isinstance(concept.lineage, WINDOW_TYPES):
+        raise ValueError
+    base = []
+    if concept.lineage.over:
+        base += concept.lineage.over
+    if concept.lineage.order_by:
+        for item in concept.lineage.order_by:
+            base += item.concept_arguments
+
+    return concept.lineage.content, unique(base, "address")
+
+
+def gen_window_node(
+    concept: BuildConcept,
+    local_optional: list[BuildConcept],
+    environment: BuildEnvironment,
+    g,
+    depth: int,
+    source_concepts,
+    history: History,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    base, parent_concepts = resolve_window_parent_concepts(concept, environment)
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} generating window node for {concept} with parents {parent_concepts} and optional {local_optional}"
+    )
+    equivalent_optional = [
+        x
+        for x in local_optional
+        if isinstance(x.lineage, WINDOW_TYPES)
+        and resolve_window_parent_concepts(x, environment)[1] == parent_concepts
+    ]
+
+    targets = [base]
+    # append in keys to get the right grain
+    if concept.keys:
+        for item in concept.keys:
+            targets.append(environment.concepts[item])
+    additional_outputs = []
+    if equivalent_optional:
+        for x in equivalent_optional:
+            assert isinstance(x.lineage, WINDOW_TYPES)
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} found equivalent optional {x} with parents {resolve_window_parent_concepts(x, environment)[1]}"
+            )
+            additional_outputs.append(x)
+
+    grain_equivalents = [
+        x for x in local_optional if x.keys and all([key in targets for key in x.keys])
+    ]
+
+    for x in grain_equivalents:
+        targets.append(x)
+
+    # finally, the ones we'll need to enrich
+    non_equivalent_optional = [x for x in local_optional if x.address not in targets]
+
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} resolving final parents {parent_concepts + targets}"
+    )
+    parent_node: StrategyNode = source_concepts(
+        mandatory_list=parent_concepts + targets,
+        environment=environment,
+        g=g,
+        depth=depth + 1,
+        history=history,
+        conditions=conditions,
+    )
+    if not parent_node:
+        logger.info(f"{padding(depth)}{LOGGER_PREFIX} window node parents unresolvable")
+        return None
+    parent_node.resolve()
+    if not all(
+        [
+            x.address in [y.address for y in parent_node.output_concepts]
+            for x in parent_concepts
+        ]
+    ):
+        missing = [
+            x
+            for x in parent_concepts
+            if x.address not in [y.address for y in parent_node.output_concepts]
+        ]
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} window node parents unresolvable, missing {missing}"
+        )
+        raise SyntaxError
+    _window_node = WindowNode(
+        input_concepts=parent_concepts + targets,
+        output_concepts=[concept] + additional_outputs + parent_concepts + targets,
+        environment=environment,
+        parents=[
+            parent_node,
+        ],
+        depth=depth,
+        preexisting_conditions=conditions.conditional if conditions else None,
+    )
+    _window_node.rebuild_cache()
+    _window_node.resolve()
+    window_node = StrategyNode(
+        input_concepts=[concept] + additional_outputs + parent_concepts + targets,
+        output_concepts=[concept] + additional_outputs + parent_concepts + targets,
+        environment=environment,
+        parents=[_window_node],
+        preexisting_conditions=conditions.conditional if conditions else None,
+        # hidden_concepts=[
+        #     x.address for x in parent_concepts if x.address not in local_optional
+        # ],
+    )
+    if not non_equivalent_optional:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} no optional concepts, returning window node"
+        )
+        return window_node
+
+    missing_optional = [
+        x.address
+        for x in local_optional
+        if x.address not in window_node.output_concepts
+    ]
+
+    if not missing_optional:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} no extra enrichment needed for window node, has all of {[x.address for x in local_optional]}"
+        )
+        return window_node
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} window node for {concept.address} requires enrichment, missing {missing_optional}, has {[x.address for x in window_node.output_concepts]}"
+    )
+
+    return gen_enrichment_node(
+        window_node,
+        join_keys=[
+            environment.concepts[c]
+            for c in BuildGrain.from_concepts(
+                concepts=targets, environment=environment
+            ).components
+        ],
+        local_optional=local_optional,
+        environment=environment,
+        g=g,
+        depth=depth,
+        source_concepts=source_concepts,
+        log_lambda=create_log_lambda(LOGGER_PREFIX, depth, logger),
+        history=history,
+        conditions=conditions,
+    )

{pytrilogy-0.0.3.27 → pytrilogy-0.0.3.28}/trilogy/core/processing/nodes/window_node.py

@@ -1,7 +1,13 @@
 from typing import List
 
 from trilogy.core.enums import SourceType
-from trilogy.core.models.build import BuildConcept, BuildOrderBy
+from trilogy.core.models.build import (
+    BuildComparison,
+    BuildConcept,
+    BuildConditional,
+    BuildOrderBy,
+    BuildParenthetical,
+)
 from trilogy.core.models.execute import QueryDatasource
 from trilogy.core.processing.nodes.base_node import StrategyNode
 
@@ -18,6 +24,9 @@ class WindowNode(StrategyNode):
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
         ordering: BuildOrderBy | None = None,
+        preexisting_conditions: (
+            BuildConditional | BuildComparison | BuildParenthetical | None
+        ) = None,
     ):
         super().__init__(
             input_concepts=input_concepts,
@@ -27,6 +36,7 @@ class WindowNode(StrategyNode):
             parents=parents,
             depth=depth,
             ordering=ordering,
+            preexisting_conditions=preexisting_conditions,
         )
 
     def _resolve(self) -> QueryDatasource:
@@ -42,4 +52,5 @@ class WindowNode(StrategyNode):
             parents=self.parents,
             depth=self.depth,
             ordering=self.ordering,
+            preexisting_conditions=self.preexisting_conditions,
         )

{pytrilogy-0.0.3.27 → pytrilogy-0.0.3.28}/trilogy/parsing/common.py

@@ -417,7 +417,14 @@ def window_item_to_concept(
     bcontent = environment.concepts[parent.content.address]
     if isinstance(bcontent, UndefinedConcept):
         return UndefinedConcept(address=f"{namespace}.{name}", metadata=fmetadata)
-    local_purpose, keys = get_purpose_and_keys(None, (bcontent,), environment)
+
+    if bcontent.purpose == Purpose.METRIC:
+        local_purpose, keys = get_purpose_and_keys(None, (bcontent,), environment)
+    else:
+        local_purpose = Purpose.PROPERTY
+        keys = {
+            bcontent.address,
+        }
 
     if parent.order_by:
         grain_components = parent.over + [bcontent.output]

pytrilogy-0.0.3.27/trilogy/core/processing/node_generators/window_node.py

@@ -1,105 +0,0 @@
-from typing import List
-
-from trilogy.constants import logger
-from trilogy.core.models.build import BuildConcept, BuildWhereClause, BuildWindowItem
-from trilogy.core.models.build_environment import BuildEnvironment
-from trilogy.core.processing.nodes import History, StrategyNode, WindowNode
-from trilogy.core.processing.utility import padding
-from trilogy.utility import unique
-
-LOGGER_PREFIX = "[GEN_WINDOW_NODE]"
-
-
-WINDOW_TYPES = (BuildWindowItem,)
-
-
-def resolve_window_parent_concepts(
-    concept: BuildConcept, environment: BuildEnvironment
-) -> tuple[BuildConcept, List[BuildConcept]]:
-    if not isinstance(concept.lineage, WINDOW_TYPES):
-        raise ValueError
-    base = []
-    if concept.lineage.over:
-        base += concept.lineage.over
-    if concept.lineage.order_by:
-        for item in concept.lineage.order_by:
-            base += item.concept_arguments
-    return concept.lineage.content, unique(base, "address")
-
-
-def gen_window_node(
-    concept: BuildConcept,
-    local_optional: list[BuildConcept],
-    environment: BuildEnvironment,
-    g,
-    depth: int,
-    source_concepts,
-    history: History | None = None,
-    conditions: BuildWhereClause | None = None,
-) -> StrategyNode | None:
-    base, parent_concepts = resolve_window_parent_concepts(concept, environment)
-    logger.info(
-        f"{padding(depth)}{LOGGER_PREFIX} generating window node for {concept} with parents {parent_concepts}"
-    )
-    equivalent_optional = [
-        x
-        for x in local_optional
-        if isinstance(x.lineage, WINDOW_TYPES)
-        and resolve_window_parent_concepts(x, environment)[1] == parent_concepts
-    ]
-
-    non_equivalent_optional = [
-        x for x in local_optional if x.address not in equivalent_optional
-    ]
-    targets = [base]
-    if equivalent_optional:
-        for x in equivalent_optional:
-            assert isinstance(x.lineage, WINDOW_TYPES)
-            targets.append(x.lineage.content)
-
-    parent_node: StrategyNode = source_concepts(
-        mandatory_list=parent_concepts + targets + non_equivalent_optional,
-        environment=environment,
-        g=g,
-        depth=depth + 1,
-        history=history,
-        conditions=conditions,
-    )
-    if not parent_node:
-        logger.info(f"{padding(depth)}{LOGGER_PREFIX} window node parents unresolvable")
-        return None
-    parent_node.resolve()
-    if not all(
-        [
-            x.address in [y.address for y in parent_node.output_concepts]
-            for x in parent_concepts
-        ]
-    ):
-        missing = [
-            x
-            for x in parent_concepts
-            if x.address not in [y.address for y in parent_node.output_concepts]
-        ]
-        logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} window node parents unresolvable, missing {missing}"
-        )
-        raise SyntaxError
-    _window_node = WindowNode(
-        input_concepts=parent_concepts + targets + non_equivalent_optional,
-        output_concepts=[concept] + parent_concepts + local_optional,
-        environment=environment,
-        parents=[
-            parent_node,
-        ],
-        depth=depth,
-    )
-    _window_node.rebuild_cache()
-    _window_node.resolve()
-    window_node = StrategyNode(
-        input_concepts=[concept] + local_optional,
-        output_concepts=[concept] + local_optional,
-        environment=environment,
-        parents=[_window_node],
-        preexisting_conditions=conditions.conditional if conditions else None,
-    )
-    return window_node