pytrilogy 0.3.485__tar.gz → 0.3.486__tar.gz

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.3.485
+Version: 0.3.486
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/__init__.py

@@ -7,7 +7,7 @@ if TYPE_CHECKING:
     from trilogy.executor import Executor
     from trilogy.parser import parse
 
-__version__ = "0.3.485"
+__version__ = "0.3.486"
 
 __all__ = [
     "CONFIG",

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/core/processing/aggregate_rollup.py

@@ -244,6 +244,20 @@ def filter_finer_row_args(
     ]
 
 
+def joinable_property(
+    concept: BuildConcept | None, datasource: BuildDatasource
+) -> bool:
+    """A dimension's column keyed on `datasource`'s grain: a join onto its rows
+    supplies it at that grain."""
+    return (
+        concept is not None
+        and concept.lineage is None
+        and concept.purpose == Purpose.PROPERTY
+        and bool(concept.keys)
+        and set(concept.keys or ()) <= set(datasource.grain.components)
+    )
+
+
 def finer_than_grain(
     concept: BuildConcept,
     grain: BuildGrain,

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/core/processing/concept_strategies_v4.py

@@ -52,6 +52,7 @@ from trilogy.core.processing.aggregate_rollup import (
     at_own_grain,
     filter_finer_row_args,
     holds_every_kept_row,
+    joinable_property,
     source_rollup_concepts,
     sourced_arguments,
 )
@@ -988,13 +989,10 @@ def _finer_filter_reaches_rollup(
     demands = [c for c in mandatory_list if c.address not in rolled_roots]
     assert where is not None
     # an atom over a stored aggregate filters only the pinned scan's own rows,
-    # so every other demand must be a column of that scan
+    # so every other demand must be a column of that scan, or a dimension's
+    # column keyed on its grain (`_plan_joined_filter_rollup` joins it on)
     if not is_scalar_condition(where.conditional):
-        return any(
-            {c.canonical_address for c in demands}
-            <= {c.canonical_address for c in ds.output_concepts}
-            for ds in rollup_sources
-        )
+        return any(_rides_summary_scan(demands, ds) for ds in rollup_sources)
     reached = walk_lineage(
         [c for c in mandatory_list if c.address not in rolled_roots],
         descend=lambda c: c.address not in rolled_roots,
@@ -1024,6 +1022,13 @@ def _finer_filter_reaches_rollup(
     )
 
 
+def _rides_summary_scan(demands: list[BuildConcept], ds: BuildDatasource) -> bool:
+    bound = {c.canonical_address for c in ds.output_concepts}
+    return all(
+        c.canonical_address in bound or joinable_property(c, ds) for c in demands
+    )
+
+
 def _aggregates_rolled_groups(
     concept: BuildConcept,
     rolled_roots: set[str],

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/core/processing/v4_helper/group_graph.py

@@ -17,7 +17,7 @@ single bucket). No derivation is privileged in the orchestrator.
 
 from collections import defaultdict
 from collections.abc import Sequence
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 
 from trilogy.constants import logger
 from trilogy.core import graph as nx
@@ -2344,12 +2344,18 @@ def build_group_graph(
         environment,
         rollup_padded,
     )
-    grouping = _elect_grouping_providers(
-        group_graph, group_edges, attrs, concept_attrs, environment
-    )
-    _state_projection_grains(attrs, buckets, grouping)
+    folds = _elect_folds(group_graph, group_edges, attrs, concept_attrs)
+    grouping = _elect_grouping_providers(group_graph, attrs, environment, folds)
+    placed = _place_projections(group_graph, group_edges, attrs, buckets, grouping)
+    _fold_groups(group_graph, group_edges, attrs, buckets, folds)
     _rehome_groups(
-        group_graph, group_edges, attrs, buckets, concept_attrs, environment, grouping
+        group_graph,
+        group_edges,
+        attrs,
+        buckets,
+        concept_attrs,
+        environment,
+        placed,
     )
     trace_group_graph(
         "FINAL added, concept sets computed, sources regrafted",
@@ -2458,16 +2464,13 @@ def trace_group_graph(
 @dataclass(frozen=True)
 class RowProvider:
     """The row source a regraftable group is re-homed onto: the parent it
-    reads, the lineage parents that parent replaces, the dimension ROOT minted
-    for it, and whether the parent renders the group inline. Once elected
-    (`_as_rewrite`) it holds only what the graph lacks: `parent` is None when
-    already a parent."""
+    reads, the lineage parents that parent replaces, and the dimension ROOT
+    minted for it. Once elected (`_as_rewrite`) it holds only what the graph
+    lacks: `parent` is None when already a parent."""
 
     parent: str | None
     drop: frozenset[str] = frozenset()
     minted: GroupBucket | None = None
-    # the parent renders the group in its own SELECT: the group folds into it
-    inline: bool = False
 
 
 def _regraft_candidate(
@@ -2865,28 +2868,54 @@ def _inline_window(
     return parent
 
 
-def _elect_grouping_providers(
+def _elect_folds(
     group_graph: nx.DiGraph,
     group_edges: EdgeMap,
     attrs: dict[str, GroupAttrs],
     concept_attrs: dict[str, ConceptAttrs],
+) -> dict[str, str]:
+    """Each scalar BASIC a WINDOW renders inline, to that WINDOW, elected over
+    the graph stage 2 built. A fold target is a WINDOW, so no fold removes
+    another's."""
+    folds: dict[str, str] = {}
+    for gid in group_graph.nodes:
+        if gid == FINAL_NODE_ID:
+            continue
+        window = _inline_window(group_graph, group_edges, attrs, concept_attrs, gid)
+        if window is not None:
+            folds[gid] = window
+    return folds
+
+
+def _fold_groups(
+    group_graph: nx.DiGraph,
+    group_edges: EdgeMap,
+    attrs: dict[str, GroupAttrs],
+    buckets: dict[str, GroupBucket],
+    folds: dict[str, str],
+) -> None:
+    for gid, window in folds.items():
+        _absorb_group(gid, window, group_graph, group_edges, attrs, buckets)
+
+
+def _elect_grouping_providers(
+    group_graph: nx.DiGraph,
+    attrs: dict[str, GroupAttrs],
     environment: BuildEnvironment,
+    folds: dict[str, str],
 ) -> dict[str, str]:
     """Each terminal scalar projection's grouping provider, elected over the
-    graph stage 2 built. A WINDOW that renders the projection inline outranks
-    it: that projection folds and keeps its grain."""
+    graph stage 2 built. A fold outranks it: that projection keeps its grain
+    and renders in its WINDOW."""
     providers: dict[str, str] = {}
     for gid in group_graph.nodes:
-        if gid == FINAL_NODE_ID:
+        if gid == FINAL_NODE_ID or gid in folds:
             continue
         provider = _terminal_basic_grouping_provider(
             group_graph, attrs, gid, environment
         )
-        if provider is None or _inline_window(
-            group_graph, group_edges, attrs, concept_attrs, gid
-        ):
-            continue
-        providers[gid] = provider
+        if provider is not None:
+            providers[gid] = provider
     return providers
 
 
@@ -2904,39 +2933,66 @@ def _state_projection_grains(
             buckets[gid].grain_components = grain
 
 
-def _elect_row_provider(
+def _projection_placements(
     group_graph: nx.DiGraph,
     group_edges: EdgeMap,
     attrs: dict[str, GroupAttrs],
-    buckets: dict[str, GroupBucket],
-    concept_attrs: dict[str, ConceptAttrs],
-    environment: BuildEnvironment,
     grouping: dict[str, str],
-    gid: str,
-) -> RowProvider | None:
-    """Pick `gid`'s row source over the graph; mutates nothing. The choices,
-    in order: a WINDOW that renders it inline, its grouping provider (whose
-    grain it already stands at), a full-coverage sibling, a dimension ROOT, a
-    partial spine."""
-    grouping_provider = grouping.get(gid)
-    if grouping_provider is None:
-        window = _inline_window(group_graph, group_edges, attrs, concept_attrs, gid)
-        if window is not None:
-            return RowProvider(window, inline=True)
-    elif not _grain_needed_by_independent_sibling(
-        group_graph, attrs, gid, grouping_provider, grouping
-    ):
+) -> dict[str, RowProvider]:
+    """Each stated projection's edge onto its grouping provider and the
+    lineage parents it replaces, read over the graph stage 2 built. A
+    projection whose provider's grain an independent sibling co-grains on is
+    not placed: it keeps its parents and takes a row provider."""
+    placements: dict[str, RowProvider] = {}
+    for gid, provider in grouping.items():
+        if _grain_needed_by_independent_sibling(
+            group_graph, attrs, gid, provider, grouping
+        ):
+            continue
         # Placed at the provider's grain, the projection has no use for a
         # finer relation the provider was built from. Joined back, it pairs
         # the provider's groups on a non-key (a region domain on a nullable
         # description) and drops or multiplies them.
-        provider_ancestors = nx.ancestors(group_graph, grouping_provider)
+        provider_ancestors = nx.ancestors(group_graph, provider)
         drop = frozenset(
             pred
             for pred in lineage_predecessors(group_graph, group_edges, gid)
             if pred in provider_ancestors
         )
-        return RowProvider(grouping_provider, drop)
+        placements[gid] = RowProvider(provider, drop)
+    return placements
+
+
+def _place_projections(
+    group_graph: nx.DiGraph,
+    group_edges: EdgeMap,
+    attrs: dict[str, GroupAttrs],
+    buckets: dict[str, GroupBucket],
+    grouping: dict[str, str],
+) -> frozenset[str]:
+    """State each terminal projection's grain and, where no independent
+    sibling needs that grain, its lineage: an edge from its grouping provider
+    in place of the parents the provider was built from. Every projection
+    feeds only FINAL, so no placement moves another group's ancestors.
+    Returns the projections placed."""
+    _state_projection_grains(attrs, buckets, grouping)
+    placements = _projection_placements(group_graph, group_edges, attrs, grouping)
+    for gid, placement in placements.items():
+        _apply_row_provider(group_graph, group_edges, attrs, buckets, gid, placement)
+    return frozenset(placements)
+
+
+def _elect_row_provider(
+    group_graph: nx.DiGraph,
+    group_edges: EdgeMap,
+    attrs: dict[str, GroupAttrs],
+    buckets: dict[str, GroupBucket],
+    concept_attrs: dict[str, ConceptAttrs],
+    environment: BuildEnvironment,
+    gid: str,
+) -> RowProvider | None:
+    """Pick `gid`'s row source over the graph; mutates nothing. The choices,
+    in order: a full-coverage sibling, a dimension ROOT, a partial spine."""
     parent_gid = _regraft_candidate(
         group_graph, group_edges, attrs, gid, allow_partial=False
     )
@@ -2983,11 +3039,8 @@ def _apply_row_provider(
 def _as_rewrite(
     group_graph: nx.DiGraph, gid: str, provider: RowProvider
 ) -> RowProvider | None:
-    """`provider` less what the graph stage 2 built already holds, or None
-    when it changes nothing: its parent is already a parent, and it drops and
-    mints nothing."""
-    if provider.inline:
-        return provider
+    """`provider` less what the graph already holds, or None when it changes
+    nothing: its parent is already a parent, and it drops and mints nothing."""
     drop = frozenset(p for p in provider.drop if group_graph.has_edge(p, gid))
     minted = provider.minted
     if minted is not None and minted.group_id in group_graph:
@@ -3007,20 +3060,22 @@ def _elect_row_providers(
     buckets: dict[str, GroupBucket],
     concept_attrs: dict[str, ConceptAttrs],
     environment: BuildEnvironment,
-    grouping: dict[str, str],
+    placed: frozenset[str],
 ) -> dict[str, RowProvider]:
-    """Each regraftable group whose best row source is already built, elected
-    over the graph as stage 2 built it, as the rewrite it makes of that graph.
-
-    No provider is a BASIC, so no fold removes one; a parent a provider drops
-    that folds is dropped as the WINDOW its edge moves to. Concrete datasource
-    selection remains in `source_planning` and StrategyNode construction in
-    `strategy_builder`.
+    """Each regraftable group not placed at its grouping provider whose best
+    row source is already built, elected over one graph (stage 2's, with the
+    projections placed and the folds made), as the rewrite it makes of that
+    graph. A provider only adds a lineage edge, drops ROOT parents and mints
+    a ROOT.
+
+    Concrete datasource selection remains in `source_planning` and
+    StrategyNode construction in `strategy_builder`.
     """
     providers: dict[str, RowProvider] = {}
     for gid in list(group_graph.nodes):
         if (
             gid == FINAL_NODE_ID
+            or gid in placed
             or attrs[gid].derivation not in _REGRAFTABLE_DERIVATIONS
         ):
             continue
@@ -3031,27 +3086,13 @@ def _elect_row_providers(
             buckets,
             concept_attrs,
             environment,
-            grouping,
             gid,
         )
         if provider is not None:
             provider = _as_rewrite(group_graph, gid, provider)
         if provider is not None:
             providers[gid] = provider
-    folded = _folds(providers)
-    return {
-        gid: replace(p, drop=frozenset(folded.get(pred, pred) for pred in p.drop))
-        for gid, p in providers.items()
-    }
-
-
-def _folds(providers: dict[str, RowProvider]) -> dict[str, str]:
-    """Each group its provider renders inline, to that provider."""
-    return {
-        gid: p.parent
-        for gid, p in providers.items()
-        if p.inline and p.parent is not None
-    }
+    return providers
 
 
 def _rehome_groups(
@@ -3061,17 +3102,18 @@ def _rehome_groups(
     buckets: dict[str, GroupBucket],
     concept_attrs: dict[str, ConceptAttrs],
     environment: BuildEnvironment,
-    grouping: dict[str, str],
+    placed: frozenset[str],
 ) -> None:
-    """Elect every group's row provider over the graph as stage 2 built it,
-    each projection already at its grouping provider's grain, then fold each
-    group its provider renders inline and apply the rest: no election reads
-    another's fold or edges."""
+    """Elect every unplaced group's row provider over one graph, then apply
+    them all: no election reads another's edges."""
     providers = _elect_row_providers(
-        group_graph, group_edges, attrs, buckets, concept_attrs, environment, grouping
+        group_graph,
+        group_edges,
+        attrs,
+        buckets,
+        concept_attrs,
+        environment,
+        placed,
     )
-    for gid, parent in _folds(providers).items():
-        _absorb_group(gid, parent, group_graph, group_edges, attrs, buckets)
     for gid, provider in providers.items():
-        if not provider.inline:
-            _apply_row_provider(group_graph, group_edges, attrs, buckets, gid, provider)
+        _apply_row_provider(group_graph, group_edges, attrs, buckets, gid, provider)

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/core/processing/v4_helper/source_planning.py

@@ -16,7 +16,7 @@ from typing import cast
 
 from trilogy.constants import logger
 from trilogy.core.constants import parent_axis_keys
-from trilogy.core.enums import Derivation, Granularity, JoinType, Purpose
+from trilogy.core.enums import Derivation, Granularity, JoinType
 from trilogy.core.graph_models import ReferenceGraph, concept_to_node
 from trilogy.core.models.build import (
     BuildConcept,
@@ -33,6 +33,7 @@ from trilogy.core.processing.aggregate_rollup import (
     at_own_grain,
     filter_finer_row_args,
     holds_every_kept_row,
+    joinable_property,
     joined_condition_columns,
     merge_rollup_concepts,
     source_rollup_concepts,
@@ -1705,7 +1706,8 @@ def _finer_filter_rollup_source(
         if not all(
             c in canonicals
             or (
-                _joinable_property(environment.concepts.get(c), arms)
+                len(arms) == 1
+                and joinable_property(environment.concepts.get(c), arms[0])
                 and all(
                     at_own_grain(a, target_grain, environment.concepts)
                     for a in aggregates
@@ -1744,19 +1746,6 @@ def _finer_filter_rollup_source(
     return matches[0]
 
 
-def _joinable_property(
-    concept: BuildConcept | None, arms: list[BuildDatasource]
-) -> bool:
-    return (
-        concept is not None
-        and concept.lineage is None
-        and concept.purpose == Purpose.PROPERTY
-        and bool(concept.keys)
-        and len(arms) == 1
-        and set(concept.keys or ()) <= set(arms[0].grain.components)
-    )
-
-
 def _rolls_every_aggregate(
     datasource: BuildDatasource | BuildUnionDatasource,
     request: SourceRequest,

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/scripts/dependency/Cargo.lock

@@ -546,7 +546,7 @@ dependencies = [
 
 [[package]]
 name = "trilogy-parser"
-version = "0.3.485"
+version = "0.3.486"
 dependencies = [
  "clap",
  "pathdiff",

{pytrilogy-0.3.485 → pytrilogy-0.3.486}/trilogy/scripts/dependency/Cargo.toml

@@ -4,7 +4,7 @@ name = "trilogy-parser"
 # crates.io releases ride the same stream (see pythonpublish.yml), so a
 # published crate version always corresponds to the pytrilogy release
 # whose grammar it carries.
-version = "0.3.485"
+version = "0.3.486"
 edition = "2021"
 description = "Parser and import/datasource dependency resolver for the Trilogy language"
 license = "MIT"