pytrilogy 0.0.2.13__py3-none-any.whl → 0.0.2.15__py3-none-any.whl

trilogy/core/processing/node_generators/select_node.py

@@ -32,6 +32,7 @@ class DatasourceMatch:
     datasource: Datasource
     matched: LooseConceptList
     partial: LooseConceptList
+    nullable: LooseConceptList
 
     def __repr__(self):
         return f"DatasourceMatch({self.key}, {self.datasource.identifier}, {str(self.matched)}, {str(self.partial)})"
@@ -76,6 +77,7 @@ def dm_to_strategy_node(
         parents=[],
         depth=depth,
         partial_concepts=dm.partial.concepts,
+        nullable_concepts=dm.nullable.concepts,
         accept_partial=accept_partial,
         datasource=datasource,
         grain=datasource.grain,
@@ -189,6 +191,13 @@ def gen_select_nodes_from_tables_v2(
                     if not c.is_complete and c.concept.address in all_lcl
                 ]
             ),
+            nullable=LooseConceptList(
+                concepts=[
+                    c.concept
+                    for c in datasource.columns
+                    if c.is_nullable and c.concept in all_lcl
+                ]
+            ),
         )
         if not matched:
             continue
@@ -318,6 +327,12 @@ def gen_select_node_from_table(
             if not c.is_complete and c.concept in all_lcl
         ]
         partial_lcl = LooseConceptList(concepts=partial_concepts)
+        nullable_concepts = [
+            c.concept
+            for c in datasource.columns
+            if c.is_nullable and c.concept in all_lcl
+        ]
+        nullable_lcl = LooseConceptList(concepts=nullable_concepts)
         if not accept_partial and target_concept in partial_lcl:
             continue
         logger.info(
@@ -359,6 +374,7 @@ def gen_select_node_from_table(
             parents=[],
             depth=depth,
             partial_concepts=[c for c in all_concepts if c in partial_lcl],
+            nullable_concepts=[c for c in all_concepts if c in nullable_lcl],
             accept_partial=accept_partial,
             datasource=datasource,
             grain=Grain(components=all_concepts),
@@ -377,6 +393,7 @@ def gen_select_node_from_table(
                 parents=[bcandidate],
                 depth=depth,
                 partial_concepts=bcandidate.partial_concepts,
+                nullable_concepts=bcandidate.nullable_concepts,
             )
         else:
             candidate = bcandidate
@@ -469,6 +486,14 @@ def gen_select_node(
             )
         ]
 
+        all_nullable = [
+            c
+            for c in all_concepts
+            if any(
+                [c.address in [x.address for x in p.nullable_concepts] for p in parents]
+            )
+        ]
+
         if all_found:
             logger.info(
                 f"{padding(depth)}{LOGGER_PREFIX} found all optional {[c.address for c in local_optional]} via joins"
@@ -494,6 +519,7 @@ def gen_select_node(
                 parents=parents,
                 depth=depth,
                 partial_concepts=all_partial,
+                nullable_concepts=all_nullable,
                 grain=inferred_grain,
             )
 

trilogy/core/processing/node_generators/window_node.py

@@ -12,8 +12,8 @@ from trilogy.constants import logger
 from trilogy.core.processing.utility import padding, create_log_lambda
 from trilogy.core.processing.node_generators.common import (
     gen_enrichment_node,
-    concept_to_relevant_joins,
 )
+from trilogy.core.processing.utility import concept_to_relevant_joins
 
 LOGGER_PREFIX = "[GEN_WINDOW_NODE]"
 

trilogy/core/processing/nodes/base_node.py

@@ -13,6 +13,7 @@ from trilogy.core.models import (
     Comparison,
     Parenthetical,
     LooseConceptList,
+    ConceptPair,
 )
 from trilogy.core.enums import Purpose, JoinType, PurposeLineage, Granularity
 from trilogy.utility import unique
@@ -122,6 +123,26 @@ def get_all_parent_partial(
     )
 
 
+def get_all_parent_nullable(
+    all_concepts: List[Concept], parents: List["StrategyNode"]
+) -> List[Concept]:
+    return unique(
+        [
+            c
+            for c in all_concepts
+            if len(
+                [
+                    p
+                    for p in parents
+                    if c.address in [x.address for x in p.nullable_concepts]
+                ]
+            )
+            >= 1
+        ],
+        "address",
+    )
+
+
 class StrategyNode:
     source_type = SourceType.ABSTRACT
 
@@ -134,6 +155,7 @@ class StrategyNode:
         whole_grain: bool = False,
         parents: List["StrategyNode"] | None = None,
         partial_concepts: List[Concept] | None = None,
+        nullable_concepts: List[Concept] | None = None,
         depth: int = 0,
         conditions: Conditional | Comparison | Parenthetical | None = None,
         force_group: bool | None = None,
@@ -157,6 +179,9 @@ class StrategyNode:
         self.partial_concepts = partial_concepts or get_all_parent_partial(
             self.output_concepts, self.parents
         )
+        self.nullable_concepts = nullable_concepts or get_all_parent_nullable(
+            self.output_concepts, self.parents
+        )
 
         self.depth = depth
         self.conditions = conditions
@@ -269,6 +294,7 @@ class StrategyNode:
             grain=grain,
             condition=self.conditions,
             partial_concepts=self.partial_concepts,
+            nullable_concepts=self.nullable_concepts,
             force_group=self.force_group,
             hidden_concepts=self.hidden_concepts,
         )
@@ -297,6 +323,7 @@ class StrategyNode:
             whole_grain=self.whole_grain,
             parents=list(self.parents),
             partial_concepts=list(self.partial_concepts),
+            nullable_concepts=list(self.nullable_concepts),
             depth=self.depth,
             conditions=self.conditions,
             force_group=self.force_group,
@@ -314,7 +341,7 @@ class NodeJoin:
     concepts: List[Concept]
     join_type: JoinType
     filter_to_mutual: bool = False
-    concept_pairs: list[tuple[Concept, Concept]] | None = None
+    concept_pairs: list[ConceptPair] | None = None
 
     def __post_init__(self):
         if self.concept_pairs:

trilogy/core/processing/nodes/group_node.py

@@ -20,6 +20,7 @@ from trilogy.core.processing.nodes.base_node import (
 )
 from trilogy.utility import unique
 from trilogy.core.processing.utility import is_scalar_condition
+from trilogy.core.processing.utility import find_nullable_concepts
 
 LOGGER_PREFIX = "[CONCEPT DETAIL - GROUP NODE]"
 
@@ -37,6 +38,7 @@ class GroupNode(StrategyNode):
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
         partial_concepts: Optional[List[Concept]] = None,
+        nullable_concepts: Optional[List[Concept]] = None,
         force_group: bool | None = None,
         conditions: Conditional | Comparison | Parenthetical | None = None,
         existence_concepts: List[Concept] | None = None,
@@ -50,6 +52,7 @@ class GroupNode(StrategyNode):
             parents=parents,
             depth=depth,
             partial_concepts=partial_concepts,
+            nullable_concepts=nullable_concepts,
             force_group=force_group,
             conditions=conditions,
             existence_concepts=existence_concepts,
@@ -113,27 +116,34 @@ class GroupNode(StrategyNode):
                     f" {parent.grain}"
                 )
             source_type = SourceType.GROUP
-
+        source_map = resolve_concept_map(
+            parent_sources,
+            targets=(
+                unique(
+                    self.output_concepts + self.conditions.concept_arguments,
+                    "address",
+                )
+                if self.conditions
+                else self.output_concepts
+            ),
+            inherited_inputs=self.input_concepts + self.existence_concepts,
+        )
+        nullable_addresses = find_nullable_concepts(
+            source_map=source_map, joins=[], datasources=parent_sources
+        )
+        nullable_concepts = [
+            x for x in self.output_concepts if x.address in nullable_addresses
+        ]
         base = QueryDatasource(
             input_concepts=self.input_concepts,
             output_concepts=self.output_concepts,
             datasources=parent_sources,
             source_type=source_type,
-            source_map=resolve_concept_map(
-                parent_sources,
-                targets=(
-                    unique(
-                        self.output_concepts + self.conditions.concept_arguments,
-                        "address",
-                    )
-                    if self.conditions
-                    else self.output_concepts
-                ),
-                inherited_inputs=self.input_concepts + self.existence_concepts,
-            ),
+            source_map=source_map,
             joins=[],
             grain=grain,
             partial_concepts=self.partial_concepts,
+            nullable_concepts=nullable_concepts,
             condition=self.conditions,
         )
         # if there is a condition on a group node and it's not scalar
@@ -141,18 +151,20 @@ class GroupNode(StrategyNode):
         if self.conditions and not is_scalar_condition(self.conditions):
             base.condition = None
             base.output_concepts = self.output_concepts + self.conditions.row_arguments
+            source_map = resolve_concept_map(
+                [base],
+                targets=self.output_concepts,
+                inherited_inputs=base.output_concepts,
+            )
             return QueryDatasource(
                 input_concepts=base.output_concepts,
                 output_concepts=self.output_concepts,
                 datasources=[base],
                 source_type=SourceType.SELECT,
-                source_map=resolve_concept_map(
-                    [base],
-                    targets=self.output_concepts,
-                    inherited_inputs=base.output_concepts,
-                ),
+                source_map=source_map,
                 joins=[],
                 grain=grain,
+                nullable_concepts=base.nullable_concepts,
                 partial_concepts=self.partial_concepts,
                 condition=self.conditions,
             )
@@ -168,6 +180,7 @@ class GroupNode(StrategyNode):
             parents=self.parents,
             depth=self.depth,
             partial_concepts=list(self.partial_concepts),
+            nullable_concepts=list(self.nullable_concepts),
             force_group=self.force_group,
             conditions=self.conditions,
             existence_concepts=list(self.existence_concepts),

trilogy/core/processing/nodes/merge_node.py

@@ -22,7 +22,7 @@ from trilogy.core.processing.nodes.base_node import (
     resolve_concept_map,
     NodeJoin,
 )
-from trilogy.core.processing.utility import get_node_joins
+from trilogy.core.processing.utility import get_node_joins, find_nullable_concepts
 
 LOGGER_PREFIX = "[CONCEPT DETAIL - MERGE NODE]"
 
@@ -110,6 +110,7 @@ class MergeNode(StrategyNode):
         join_concepts: Optional[List] = None,
         force_join_type: Optional[JoinType] = None,
         partial_concepts: Optional[List[Concept]] = None,
+        nullable_concepts: Optional[List[Concept]] = None,
         force_group: bool | None = None,
         depth: int = 0,
         grain: Grain | None = None,
@@ -127,6 +128,7 @@ class MergeNode(StrategyNode):
             parents=parents,
             depth=depth,
             partial_concepts=partial_concepts,
+            nullable_concepts=nullable_concepts,
             force_group=force_group,
             grain=grain,
             conditions=conditions,
@@ -192,7 +194,7 @@ class MergeNode(StrategyNode):
         pregrain: Grain,
         grain: Grain,
         environment: Environment,
-    ) -> List[BaseJoin]:
+    ) -> List[BaseJoin | UnnestJoin]:
         # only finally, join between them for unique values
         dataset_list: List[QueryDatasource] = sorted(
             final_datasets, key=lambda x: -len(x.grain.components_copy)
@@ -308,7 +310,7 @@ class MergeNode(StrategyNode):
         )
         join_candidates = [x for x in final_datasets if x not in existence_final]
         if len(join_candidates) > 1:
-            joins = self.generate_joins(
+            joins: List[BaseJoin | UnnestJoin] = self.generate_joins(
                 join_candidates, final_joins, pregrain, grain, self.environment
             )
         else:
@@ -318,7 +320,7 @@ class MergeNode(StrategyNode):
         )
         full_join_concepts = []
         for join in joins:
-            if join.join_type == JoinType.FULL:
+            if isinstance(join, BaseJoin) and join.join_type == JoinType.FULL:
                 full_join_concepts += join.concepts
         if self.whole_grain:
             force_group = False
@@ -341,6 +343,9 @@ class MergeNode(StrategyNode):
             inherited_inputs=self.input_concepts + self.existence_concepts,
             full_joins=full_join_concepts,
         )
+        nullable_concepts = find_nullable_concepts(
+            source_map=source_map, joins=joins, datasources=final_datasets
+        )
         qds = QueryDatasource(
             input_concepts=unique(self.input_concepts, "address"),
             output_concepts=unique(self.output_concepts, "address"),
@@ -349,6 +354,9 @@ class MergeNode(StrategyNode):
             source_map=source_map,
             joins=qd_joins,
             grain=grain,
+            nullable_concepts=[
+                x for x in self.output_concepts if x.address in nullable_concepts
+            ],
             partial_concepts=self.partial_concepts,
             force_group=force_group,
             condition=self.conditions,
@@ -369,6 +377,7 @@ class MergeNode(StrategyNode):
             force_group=self.force_group,
             grain=self.grain,
             conditions=self.conditions,
+            nullable_concepts=list(self.nullable_concepts),
             hidden_concepts=list(self.hidden_concepts),
             virtual_output_concepts=list(self.virtual_output_concepts),
             node_joins=list(self.node_joins) if self.node_joins else None,

trilogy/core/processing/nodes/select_node_v2.py

@@ -43,6 +43,7 @@ class SelectNode(StrategyNode):
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
         partial_concepts: List[Concept] | None = None,
+        nullable_concepts: List[Concept] | None = None,
         accept_partial: bool = False,
         grain: Optional[Grain] = None,
         force_group: bool | None = False,
@@ -58,6 +59,7 @@ class SelectNode(StrategyNode):
             parents=parents,
             depth=depth,
             partial_concepts=partial_concepts,
+            nullable_concepts=nullable_concepts,
             force_group=force_group,
             grain=grain,
             conditions=conditions,
@@ -115,6 +117,7 @@ class SelectNode(StrategyNode):
             partial_concepts=[
                 c.concept for c in datasource.columns if not c.is_complete
             ],
+            nullable_concepts=[c.concept for c in datasource.columns if c.is_nullable],
             source_type=SourceType.DIRECT_SELECT,
             condition=self.conditions,
             # select nodes should never group
@@ -183,6 +186,7 @@ class SelectNode(StrategyNode):
             parents=self.parents,
             whole_grain=self.whole_grain,
             partial_concepts=list(self.partial_concepts),
+            nullable_concepts=list(self.nullable_concepts),
             accept_partial=self.accept_partial,
             grain=self.grain,
             force_group=self.force_group,

trilogy/core/processing/utility.py

@@ -18,9 +18,11 @@ from trilogy.core.models import (
     WindowItem,
     AggregateWrapper,
     DataType,
+    ConceptPair,
+    UnnestJoin,
 )
 
-from trilogy.core.enums import Purpose, Granularity, BooleanOperator
+from trilogy.core.enums import Purpose, Granularity, BooleanOperator, Modifier
 from trilogy.core.constants import CONSTANT_DATASET
 from enum import Enum
 from trilogy.utility import unique
@@ -243,8 +245,23 @@ def get_node_joins(
             local_concepts = [
                 c for c in local_concepts if c.granularity != Granularity.SINGLE_ROW
             ]
-        else:
+        elif any(
+            [
+                c.address in [x.address for x in identifier_map[right].partial_concepts]
+                for c in local_concepts
+            ]
+        ) or any(
+            [
+                c.address in [x.address for x in identifier_map[left].nullable_concepts]
+                for c in local_concepts
+            ]
+        ):
             join_type = JoinType.LEFT_OUTER
+            local_concepts = [
+                c for c in local_concepts if c.granularity != Granularity.SINGLE_ROW
+            ]
+        else:
+            join_type = JoinType.INNER
             # remove any constants if other join keys exist
             local_concepts = [
                 c for c in local_concepts if c.granularity != Granularity.SINGLE_ROW
@@ -287,7 +304,18 @@ def get_node_joins(
                     )
             narg = (left_arg, right_arg)
             if narg not in join_tuples:
-                join_tuples.append((left_arg, right_arg))
+                modifiers = set()
+                if left_arg.address in [
+                    x.address for x in left_datasource.nullable_concepts
+                ] and right_arg.address in [
+                    x.address for x in right_datasource.nullable_concepts
+                ]:
+                    modifiers.add(Modifier.NULLABLE)
+                join_tuples.append(
+                    ConceptPair(
+                        left=left_arg, right=right_arg, modifiers=list(modifiers)
+                    )
+                )
         final_joins_pre.append(
             BaseJoin(
                 left_datasource=identifier_map[left],
@@ -412,3 +440,63 @@ def decompose_condition(
     else:
         chunks.append(conditional)
     return chunks
+
+
+def find_nullable_concepts(
+    source_map: Dict[str, set[Datasource | QueryDatasource | UnnestJoin]],
+    datasources: List[Datasource | QueryDatasource],
+    joins: List[BaseJoin | UnnestJoin],
+) -> List[str]:
+    """give a set of datasources and joins, find the concepts
+    that may contain nulls in the output set
+    """
+    nullable_datasources = set()
+    datasource_map = {
+        x.identifier: x
+        for x in datasources
+        if isinstance(x, (Datasource, QueryDatasource))
+    }
+    for join in joins:
+        is_on_nullable_condition = False
+        if not isinstance(join, BaseJoin):
+            continue
+        if not join.concept_pairs:
+            continue
+        for pair in join.concept_pairs:
+            if pair.right.address in [
+                y.address
+                for y in datasource_map[
+                    join.right_datasource.identifier
+                ].nullable_concepts
+            ]:
+                is_on_nullable_condition = True
+                break
+            if pair.left.address in [
+                y.address
+                for y in datasource_map[
+                    join.left_datasource.identifier
+                ].nullable_concepts
+            ]:
+                is_on_nullable_condition = True
+                break
+        if is_on_nullable_condition:
+            nullable_datasources.add(datasource_map[join.right_datasource.identifier])
+    final_nullable = set()
+
+    for k, v in source_map.items():
+        local_nullable = [
+            x for x in datasources if k in [v.address for v in x.nullable_concepts]
+        ]
+        if all(
+            [
+                k in [v.address for v in x.nullable_concepts]
+                for x in datasources
+                if k in [z.address for z in x.output_concepts]
+            ]
+        ):
+            final_nullable.add(k)
+        all_ds = set([ds for ds in local_nullable]).union(nullable_datasources)
+        if nullable_datasources:
+            if set(v).issubset(all_ds):
+                final_nullable.add(k)
+    return list(sorted(final_nullable))

trilogy/core/query_processor.py

@@ -192,8 +192,6 @@ def resolve_cte_base_name_and_alias_v2(
     raw_joins: List[Join | InstantiatedUnnestJoin],
 ) -> Tuple[str | None, str | None]:
     joins: List[Join] = [join for join in raw_joins if isinstance(join, Join)]
-    # INFO     trilogy:query_processor.py:263 Finished building source map for civet with 3 parents, have {'local.relevant_customers': ['fowl', 'fowl'],
-    # 'customer.demographics.gender': ['mandrill'], 'customer.id': ['mandrill'], 'customer.demographics.id': ['mandrill'], 'customer.id_9268029262289908': [], 'customer.demographics.gender_1513806568509111': []}, query_datasource had non-empty keys ['local.relevant_customers', 'customer.demographics.gender', 'customer.id', 'customer.demographics.id'] and existence had non-empty keys []
     if (
         len(source.datasources) == 1
         and isinstance(source.datasources[0], Datasource)
@@ -297,6 +295,7 @@ def datasource_to_ctes(
         parent_ctes=parents,
         condition=query_datasource.condition,
         partial_concepts=query_datasource.partial_concepts,
+        nullable_concepts=query_datasource.nullable_concepts,
         join_derived_concepts=query_datasource.join_derived_concepts,
         hidden_concepts=query_datasource.hidden_concepts,
         base_name_override=base_name,

trilogy/dialect/common.py

@@ -3,9 +3,9 @@ from trilogy.core.enums import UnnestMode, Modifier
 from typing import Optional, Callable
 
 
-def null_wrapper(lval: str, rval: str, concept: Concept) -> str:
-    if concept.modifiers and Modifier.NULLABLE in concept.modifiers:
-        return f"(({lval} is null and {rval} is null) or ({lval} = {rval}))"
+def null_wrapper(lval: str, rval: str, modifiers: list[Modifier]) -> str:
+    if Modifier.NULLABLE in modifiers:
+        return f"({lval} = {rval} or ({lval} is null and {rval} is null))"
     return f"{lval} = {rval}"
 
 
@@ -48,7 +48,7 @@ def render_join(
         null_wrapper(
             f"{left_name}.{quote_character}{join.left_cte.get_alias(key.concept) if isinstance(join.left_cte, Datasource) else key.concept.safe_address}{quote_character}",
             f"{right_name}.{quote_character}{join.right_cte.get_alias(key.concept) if isinstance(join.right_cte, Datasource) else key.concept.safe_address}{quote_character}",
-            key.concept,
+            modifiers=key.concept.modifiers or [],
         )
         for key in join.joinkeys
     ]
@@ -56,11 +56,13 @@ def render_join(
         base_joinkeys.extend(
             [
                 null_wrapper(
-                    f"{left_name}.{quote_character}{join.left_cte.get_alias(left_concept) if isinstance(join.left_cte, Datasource) else left_concept.safe_address}{quote_character}",
-                    f"{right_name}.{quote_character}{join.right_cte.get_alias(right_concept) if isinstance(join.right_cte, Datasource) else right_concept.safe_address}{quote_character}",
-                    left_concept,
+                    f"{left_name}.{quote_character}{join.left_cte.get_alias(pair.left) if isinstance(join.left_cte, Datasource) else pair.left.safe_address}{quote_character}",
+                    f"{right_name}.{quote_character}{join.right_cte.get_alias(pair.right) if isinstance(join.right_cte, Datasource) else pair.right.safe_address}{quote_character}",
+                    modifiers=pair.modifiers
+                    + (pair.left.modifiers or [])
+                    + (pair.right.modifiers or []),
                 )
-                for left_concept, right_concept in join.joinkey_pairs
+                for pair in join.joinkey_pairs
             ]
         )
     if not base_joinkeys:

trilogy/parsing/common.py

@@ -25,6 +25,15 @@ from trilogy.core.enums import PurposeLineage
 from trilogy.constants import (
     VIRTUAL_CONCEPT_PREFIX,
 )
+from trilogy.core.enums import Modifier
+
+
+def get_upstream_modifiers(keys: List[Concept]) -> list[Modifier]:
+    modifiers = set()
+    for pkey in keys:
+        if pkey.modifiers:
+            modifiers.update(pkey.modifiers)
+    return list(modifiers)
 
 
 def process_function_args(
@@ -125,7 +134,7 @@ def constant_to_concept(
 
 
 def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
-    pkeys = []
+    pkeys: List[Concept] = []
     for x in parent.arguments:
         pkeys += [
             x
@@ -135,7 +144,7 @@ def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
     grain = Grain()
     for x in pkeys:
         grain += x.grain
-
+    modifiers = get_upstream_modifiers(pkeys)
     key_grain = []
     for x in pkeys:
         if x.keys:
@@ -155,6 +164,7 @@ def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
         namespace=namespace,
         grain=grain,
         keys=keys,
+        modifiers=modifiers,
     )
 
 
@@ -166,6 +176,7 @@ def filter_item_to_concept(
     metadata: Metadata | None = None,
 ) -> Concept:
     fmetadata = metadata or Metadata()
+    modifiers = get_upstream_modifiers(parent.content.concept_arguments)
     return Concept(
         name=name,
         datatype=parent.content.datatype,
@@ -184,6 +195,7 @@ def filter_item_to_concept(
             if parent.content.purpose == Purpose.PROPERTY
             else Grain()
         ),
+        modifiers=modifiers,
     )
 
 
@@ -202,6 +214,7 @@ def window_item_to_concept(
             grain += [item.expr.output]
     else:
         grain = parent.over + [parent.content.output]
+    modifiers = get_upstream_modifiers(parent.content.concept_arguments)
     return Concept(
         name=name,
         datatype=parent.content.datatype,
@@ -212,6 +225,7 @@ def window_item_to_concept(
         grain=Grain(components=grain),
         namespace=namespace,
         keys=keys,
+        modifiers=modifiers,
     )
 
 
@@ -229,6 +243,7 @@ def agg_wrapper_to_concept(
     # at that grain
     fmetadata = metadata or Metadata()
     aggfunction = parent.function
+    modifiers = get_upstream_modifiers(parent.concept_arguments)
     out = Concept(
         name=name,
         datatype=aggfunction.output_datatype,
@@ -238,6 +253,7 @@ def agg_wrapper_to_concept(
         grain=Grain(components=parent.by) if parent.by else Grain(),
         namespace=namespace,
         keys=tuple(parent.by) if parent.by else keys,
+        modifiers=modifiers,
     )
     return out