pytrilogy 0.3.485__tar.gz → 0.3.487__tar.gz

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

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

{pytrilogy-0.3.485 → pytrilogy-0.3.487}/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.487"
 
 __all__ = [
     "CONFIG",

{pytrilogy-0.3.485 → pytrilogy-0.3.487}/trilogy/core/optimizations/predicate_pushdown.py

@@ -169,6 +169,23 @@ def _parent_holds_the_same_concepts(candidate: BuildConceptArgs, parent: CTE) ->
     )
 
 
+def _parent_holds_partial(
+    candidate: BuildConceptArgs,
+    parent: CTE,
+    inverse_map: dict[str, list[CTE | UnionCTE]],
+) -> bool:
+    """A child of `parent` re-aggregates a column the predicate reads under
+    the same address, so `parent` holds one partial per finer group, not the
+    value the predicate tests (`Rollup.coarse_gate_on_partial_misfilters`)."""
+    rolled = {
+        c.address
+        for child in inverse_map.get(parent.name, [])
+        if isinstance(child, CTE) and child.group_to_grain
+        for c in child.rollup_concepts
+    }
+    return any(arg.address in rolled for arg in candidate.row_arguments)
+
+
 def _parent_materialized_addrs(parent: CTE | UnionCTE) -> set[str]:
     """Addresses a parent CTE exposes as plain output columns: a non-empty
     ``source_map`` entry means the concept is pulled from upstream rather than
@@ -569,6 +586,12 @@ class PredicatePushdown(OptimizationRule):
             return False
         if not _parent_holds_the_same_concepts(candidate, parent_cte):
             return False
+        if _parent_holds_partial(candidate, parent_cte, inverse_map):
+            self.debug(
+                f"{parent_cte.name} holds a partial of {candidate}'s value that a "
+                "child re-aggregates under the same address; not pushing"
+            )
+            return False
         materialized = _rendered_source_columns(parent_cte)
 
         if not row_conditions or not materialized:

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

@@ -212,20 +212,36 @@ def _conditions_supported(
     datasource: BuildDatasource,
     conditions: BuildWhereClause | None,
     concepts_by_address: Mapping[str, BuildConcept] | None = None,
+    joined: bool = False,
 ) -> bool:
+    """With `joined`, an aggregate at a grain inside the summary's
+    (`sum(x) by city` beside `(city, species)`) is a function of its key, which
+    the joined plan computes in its own group and joins back
+    (`Rollup.coarse_group_value_filter_exact`). A scan of the summary alone
+    would read the stored partial as that value."""
     if not conditions:
         return True
+    grain = set(datasource.grain.components)
     return _concepts_reachable(
         datasource,
         [
             c
             for c in conditions.row_arguments
             if c.granularity != Granularity.SINGLE_ROW
+            and not (joined and _keyed_aggregate(c, grain))
         ],
         concepts_by_address,
     )
 
 
+def _keyed_aggregate(concept: BuildConcept, grain: set[str]) -> bool:
+    return (
+        concept.derivation == Derivation.AGGREGATE
+        and bool(concept.grain.components)
+        and concept.grain.components <= grain
+    )
+
+
 def filter_finer_row_args(
     conditions: BuildWhereClause | None,
     target_grain: BuildGrain,
@@ -244,6 +260,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,
@@ -351,7 +381,7 @@ def get_rollup_concepts(
     """The requested aggregates `datasource` rolls up to `target_grain`. With
     `joined`, `agg(x ? c)` may read `c` from a join onto the summary's rows
     (`_datasource_has_matching_rollup_aggregate`)."""
-    if not _conditions_supported(datasource, conditions, concepts_by_address):
+    if not _conditions_supported(datasource, conditions, concepts_by_address, joined):
         return []
     reach = concepts_by_address if joined else None
 

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

@@ -28,7 +28,7 @@ from contextlib import nullcontext
 
 from trilogy.constants import logger
 from trilogy.core import graph as nx
-from trilogy.core.enums import Derivation
+from trilogy.core.enums import Derivation, Granularity
 from trilogy.core.exceptions import UnbuiltGroupException
 from trilogy.core.graph_models import ReferenceGraph
 from trilogy.core.models.build import (
@@ -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,
 )
@@ -849,7 +850,14 @@ def _rollup_sources(
     summaries read."""
     out: list[BuildDatasource] = []
     sources: list[BuildDatasource | BuildUnionDatasource] = [*datasources, *unions]
+    gated = _coarse_gate_beside_row_columns(where, target_grain)
     for source in sources:
+        if (
+            gated
+            and isinstance(source, BuildDatasource)
+            and _coarse_gate(where, source)
+        ):
+            continue
         if not holds_every_kept_row(source, where):
             continue
         if isinstance(source, BuildDatasource) and not (
@@ -882,6 +890,33 @@ def _rollup_sources(
     return out
 
 
+def _coarse_gate(where: BuildWhereClause | None, source: BuildDatasource) -> bool:
+    """The WHERE reads an aggregate at a grain inside `source`'s but not at
+    it (`sum(x) by city` beside `(city, species)`): its value is a re-sum the
+    joined plan computes in its own group."""
+    grain = set(source.grain.components)
+    return where is not None and any(
+        c.derivation == Derivation.AGGREGATE
+        and c.granularity != Granularity.SINGLE_ROW
+        and set(c.grain.components) < grain
+        for c in where.row_arguments
+    )
+
+
+def _coarse_gate_beside_row_columns(
+    where: BuildWhereClause | None, target_grain: BuildGrain
+) -> bool:
+    """A row column beside the gate that the target does not group by
+    (`species != 'Tilia'` at `tree_form`) widens the pinned request past the
+    target, and the search that takes over re-aggregates the gate at it."""
+    return where is not None and any(
+        not c.is_aggregate
+        and c.granularity != Granularity.SINGLE_ROW
+        and c.address not in target_grain.components
+        for c in where.row_arguments
+    )
+
+
 def _nested_rollup_roots(
     mandatory_list: list[BuildConcept],
     roots: set[str],
@@ -988,13 +1023,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 +1056,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.487}/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,13 +2344,14 @@ 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)
-    _rehome_groups(
-        group_graph, group_edges, attrs, buckets, concept_attrs, environment, 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)
+    read = _read_dimensions(
+        group_graph, group_edges, attrs, buckets, concept_attrs, placed
     )
+    _rehome_groups(group_graph, group_edges, attrs, buckets, environment, placed | read)
     trace_group_graph(
         "FINAL added, concept sets computed, sources regrafted",
         group_graph,
@@ -2457,17 +2458,15 @@ 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."""
+    """The row source a group is re-homed onto: the parent it reads, the
+    lineage parents that parent replaces, and the dimension ROOT minted for
+    it. A placement drops; a dimension read drops and mints; a row provider
+    elected in the rehome (`_as_rewrite`) holds only the edge the graph
+    lacks."""
 
     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 +2864,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,50 +2929,67 @@ 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],
+    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 partial spine."""
     parent_gid = _regraft_candidate(
         group_graph, group_edges, attrs, gid, allow_partial=False
-    )
-    if parent_gid is not None:
-        return RowProvider(parent_gid)
-    dimension = _synthetic_dimension_regraft_parent(
-        group_graph, group_edges, attrs, buckets, concept_attrs, gid
-    )
-    if dimension is not None:
-        return dimension
-    parent_gid = _regraft_candidate(
+    ) or _regraft_candidate(
         group_graph,
         group_edges,
         attrs,
@@ -2958,6 +3000,63 @@ def _elect_row_provider(
     return None if parent_gid is None else RowProvider(parent_gid)
 
 
+def _rehomeable(
+    attrs: dict[str, GroupAttrs], gid: str, settled: frozenset[str]
+) -> bool:
+    return (
+        gid != FINAL_NODE_ID
+        and gid not in settled
+        and attrs[gid].derivation in _REGRAFTABLE_DERIVATIONS
+    )
+
+
+def _elect_dimension_reads(
+    group_graph: nx.DiGraph,
+    group_edges: EdgeMap,
+    attrs: dict[str, GroupAttrs],
+    buckets: dict[str, GroupBucket],
+    concept_attrs: dict[str, ConceptAttrs],
+    placed: frozenset[str],
+) -> dict[str, RowProvider]:
+    """Each unplaced BASIC with no full-coverage sibling that reads its inputs
+    off a dimension ROOT, elected over the folded graph. A sibling outranks
+    a dimension, so a group with one is left to the rehome."""
+    reads: dict[str, RowProvider] = {}
+    for gid in group_graph.nodes:
+        if not _rehomeable(attrs, gid, placed):
+            continue
+        if _regraft_candidate(
+            group_graph, group_edges, attrs, gid, allow_partial=False
+        ):
+            continue
+        read = _synthetic_dimension_regraft_parent(
+            group_graph, group_edges, attrs, buckets, concept_attrs, gid
+        )
+        if read is not None:
+            reads[gid] = read
+    return reads
+
+
+def _read_dimensions(
+    group_graph: nx.DiGraph,
+    group_edges: EdgeMap,
+    attrs: dict[str, GroupAttrs],
+    buckets: dict[str, GroupBucket],
+    concept_attrs: dict[str, ConceptAttrs],
+    placed: frozenset[str],
+) -> frozenset[str]:
+    """Re-home each dimension read onto its ROOT, minting it when none covers
+    its inputs, in place of the ROOT parents it replaces. Every read is
+    elected before any is applied. Returns the groups read, a pick that
+    changes nothing included: the rehome elects none of them."""
+    reads = _elect_dimension_reads(
+        group_graph, group_edges, attrs, buckets, concept_attrs, placed
+    )
+    for gid, read in reads.items():
+        _apply_row_provider(group_graph, group_edges, attrs, buckets, gid, read)
+    return frozenset(reads)
+
+
 def _apply_row_provider(
     group_graph: nx.DiGraph,
     group_edges: EdgeMap,
@@ -2983,11 +3082,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:
@@ -3004,54 +3100,30 @@ def _elect_row_providers(
     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],
+    settled: 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 nor read
+    off a dimension whose best row source is already built, elected over one
+    graph (stage 2's, with the projections placed, the folds made and the
+    dimensions read), as the rewrite it makes of that graph. A provider only
+    adds a lineage edge.
+
+    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 attrs[gid].derivation not in _REGRAFTABLE_DERIVATIONS
-        ):
+        if not _rehomeable(attrs, gid, settled):
             continue
         provider = _elect_row_provider(
-            group_graph,
-            group_edges,
-            attrs,
-            buckets,
-            concept_attrs,
-            environment,
-            grouping,
-            gid,
+            group_graph, group_edges, attrs, environment, 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(
@@ -3059,19 +3131,13 @@ def _rehome_groups(
     group_edges: EdgeMap,
     attrs: dict[str, GroupAttrs],
     buckets: dict[str, GroupBucket],
-    concept_attrs: dict[str, ConceptAttrs],
     environment: BuildEnvironment,
-    grouping: dict[str, str],
+    settled: 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 unsettled 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, environment, settled
     )
-    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.487}/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.487}/trilogy/scripts/dependency/Cargo.lock

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

{pytrilogy-0.3.485 → pytrilogy-0.3.487}/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.487"
 edition = "2021"
 description = "Parser and import/datasource dependency resolver for the Trilogy language"
 license = "MIT"