pytrilogy 0.0.3.37__tar.gz → 0.0.3.39__tar.gz

{pytrilogy-0.0.3.37/pytrilogy.egg-info → pytrilogy-0.0.3.39}/PKG-INFO

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

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/tests/test_models.py

@@ -328,7 +328,7 @@ select avg_greater_ten;
     lineage = env.concepts["avg_greater_ten"].lineage
     assert isinstance(lineage, AggregateWrapper)
     assert isinstance(
-        env.concepts[lineage.function.concept_arguments[0]].lineage, RowsetItem
+        env.concepts[lineage.function.concept_arguments[0].address].lineage, RowsetItem
     )
 
 

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

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/environment_helpers.py

@@ -1,10 +1,10 @@
 from trilogy.constants import DEFAULT_NAMESPACE
 from trilogy.core.enums import ConceptSource, DatePart, FunctionType, Purpose
-from trilogy.core.functions import AttrAccess, FunctionFactory
-from trilogy.core.models.author import Concept, Function, Metadata
+from trilogy.core.functions import AttrAccess
+from trilogy.core.models.author import Concept, Function, Metadata, TraitDataType
 from trilogy.core.models.core import DataType, StructType, arg_to_datatype
 from trilogy.core.models.environment import Environment
-from trilogy.parsing.common import Meta, process_function_args
+from trilogy.parsing.common import Meta
 
 FUNCTION_DESCRIPTION_MAPS = {
     FunctionType.DATE: "The date part of a timestamp/date. Integer, 0-31 depending on month.",
@@ -19,7 +19,6 @@ FUNCTION_DESCRIPTION_MAPS = {
 
 
 def generate_date_concepts(concept: Concept, environment: Environment):
-    factory = FunctionFactory(environment=environment)
     if concept.metadata and concept.metadata.description:
         base_description = concept.metadata.description
     else:
@@ -28,24 +27,36 @@ def generate_date_concepts(concept: Concept, environment: Environment):
         base_line_number = concept.metadata.line_number
     else:
         base_line_number = None
-    for ftype in [
-        FunctionType.MONTH,
-        FunctionType.YEAR,
-        FunctionType.QUARTER,
-        FunctionType.DAY,
-        FunctionType.DAY_OF_WEEK,
-    ]:
+    arg_tuples: list[tuple[FunctionType, TraitDataType]] = [
+        (FunctionType.MONTH, TraitDataType(type=DataType.INTEGER, traits=["month"])),
+        (FunctionType.YEAR, TraitDataType(type=DataType.INTEGER, traits=["year"])),
+        (
+            FunctionType.QUARTER,
+            TraitDataType(type=DataType.INTEGER, traits=["quarter"]),
+        ),
+        (FunctionType.DAY, TraitDataType(type=DataType.INTEGER, traits=["day"])),
+        (
+            FunctionType.DAY_OF_WEEK,
+            TraitDataType(type=DataType.INTEGER, traits=["day_of_week"]),
+        ),
+    ]
+    for ftype, dtype in arg_tuples:
         fname = ftype.name.lower()
+        address = concept.address + f".{fname}"
+        if address in environment.concepts:
+            continue
         default_type = (
             Purpose.CONSTANT
             if concept.purpose == Purpose.CONSTANT
             else Purpose.PROPERTY
         )
-        function = factory.create_function(
+        function = Function.model_construct(
             operator=ftype,
-            args=[concept],
+            arguments=[concept.reference],
+            output_datatype=dtype,
+            output_purpose=default_type,
         )
-        new_concept = Concept(
+        new_concept = Concept.model_construct(
             name=f"{concept.name}.{fname}",
             datatype=function.output_datatype,
             purpose=default_type,
@@ -61,15 +72,19 @@ def generate_date_concepts(concept: Concept, environment: Environment):
                 concept_source=ConceptSource.AUTO_DERIVED,
             ),
         )
-        if new_concept.name in environment.concepts:
-            continue
         environment.add_concept(new_concept, add_derived=False)
     for grain in [DatePart.MONTH, DatePart.YEAR]:
-        function = factory.create_function(
+        address = concept.address + f".{grain.value}_start"
+        if address in environment.concepts:
+            continue
+        function = Function.model_construct(
             operator=FunctionType.DATE_TRUNCATE,
-            args=[concept, grain],
+            arguments=[concept.reference, grain],
+            output_datatype=DataType.DATE,
+            output_purpose=default_type,
+            arg_count=2,
         )
-        new_concept = Concept(
+        new_concept = Concept.model_construct(
             name=f"{concept.name}.{grain.value}_start",
             datatype=DataType.DATE,
             purpose=Purpose.PROPERTY,
@@ -85,13 +100,11 @@ def generate_date_concepts(concept: Concept, environment: Environment):
                 concept_source=ConceptSource.AUTO_DERIVED,
             ),
         )
-        if new_concept.name in environment.concepts:
-            continue
+
         environment.add_concept(new_concept, add_derived=False)
 
 
 def generate_datetime_concepts(concept: Concept, environment: Environment):
-    factory = FunctionFactory(environment=environment)
     if concept.metadata and concept.metadata.description:
         base_description = concept.metadata.description
     else:
@@ -100,24 +113,29 @@ def generate_datetime_concepts(concept: Concept, environment: Environment):
         base_line_number = concept.metadata.line_number
     else:
         base_line_number = None
-    for ftype in [
-        FunctionType.DATE,
-        FunctionType.HOUR,
-        FunctionType.MINUTE,
-        FunctionType.SECOND,
-    ]:
+    setup_tuples: list[tuple[FunctionType, DataType | TraitDataType]] = [
+        (FunctionType.DATE, DataType.DATE),
+        (FunctionType.HOUR, TraitDataType(type=DataType.INTEGER, traits=["hour"])),
+        (FunctionType.MINUTE, TraitDataType(type=DataType.INTEGER, traits=["minute"])),
+        (FunctionType.SECOND, TraitDataType(type=DataType.INTEGER, traits=["second"])),
+    ]
+    for ftype, datatype in setup_tuples:
         fname = ftype.name.lower()
+        address = concept.address + f".{fname}"
+        if address in environment.concepts:
+            continue
         default_type = (
             Purpose.CONSTANT
             if concept.purpose == Purpose.CONSTANT
             else Purpose.PROPERTY
         )
-
-        const_function = factory.create_function(
+        const_function = Function.model_construct(
             operator=ftype,
-            args=[concept],
+            arguments=[concept.reference],
+            output_datatype=datatype,
+            output_purpose=default_type,
         )
-        new_concept = Concept(
+        new_concept = Concept.model_construct(
             name=f"{concept.name}.{fname}",
             datatype=const_function.output_datatype,
             purpose=default_type,
@@ -148,15 +166,18 @@ def generate_key_concepts(concept: Concept, environment: Environment):
     else:
         base_line_number = None
     for ftype in [FunctionType.COUNT]:
+        address = concept.address + f".{ftype.name.lower()}"
+        if address in environment.concepts:
+            continue
         fname = ftype.name.lower()
         default_type = Purpose.METRIC
-        const_function: Function = Function(
+        const_function: Function = Function.model_construct(
             operator=ftype,
             output_datatype=DataType.INTEGER,
             output_purpose=default_type,
-            arguments=[concept],
+            arguments=[concept.reference],
         )
-        new_concept = Concept(
+        new_concept = Concept.model_construct(
             name=f"{concept.name}.{fname}",
             datatype=DataType.INTEGER,
             purpose=default_type,
@@ -172,8 +193,6 @@ def generate_key_concepts(concept: Concept, environment: Environment):
                 concept_source=ConceptSource.AUTO_DERIVED,
             ),
         )
-        if new_concept.name in environment.concepts:
-            continue
         environment.add_concept(new_concept, add_derived=False)
 
 
@@ -199,10 +218,7 @@ def generate_related_concepts(
 
     if isinstance(concept.datatype, StructType):
         for key, value in concept.datatype.fields_map.items():
-            args = process_function_args(
-                [concept, key], meta=meta, environment=environment
-            )
-            auto = Concept(
+            auto = Concept.model_construct(
                 name=key,
                 datatype=arg_to_datatype(value),
                 purpose=Purpose.PROPERTY,
@@ -212,7 +228,8 @@ def generate_related_concepts(
                     and environment.namespace != DEFAULT_NAMESPACE
                     else concept.name
                 ),
-                lineage=AttrAccess(args, environment=environment),
+                lineage=AttrAccess([concept.reference, key], environment=environment),
+                grain=concept.grain,
             )
             environment.add_concept(auto, meta=meta)
             if isinstance(value, Concept):

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/functions.py

@@ -17,6 +17,7 @@ from trilogy.core.exceptions import InvalidSyntaxException
 from trilogy.core.models.author import (
     AggregateWrapper,
     Concept,
+    ConceptRef,
     Function,
     Parenthetical,
     UndefinedConcept,
@@ -35,7 +36,7 @@ from trilogy.core.models.core import (
 )
 from trilogy.core.models.environment import Environment
 
-GENERIC_ARGS = Concept | Function | str | int | float | date | datetime
+GENERIC_ARGS = Concept | ConceptRef | Function | str | int | float | date | datetime
 
 
 @dataclass
@@ -191,6 +192,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     ),
     FunctionType.GROUP: FunctionConfig(
         arg_count=-1,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
     ),
     FunctionType.COUNT: FunctionConfig(
         output_purpose=Purpose.METRIC,
@@ -772,7 +774,7 @@ class FunctionFactory:
                 output_purpose = Purpose.PROPERTY
         return Function(
             operator=operator,
-            arguments=full_args,
+            arguments=full_args,  # type: ignore
             output_datatype=final_output_type,
             output_purpose=output_purpose,
             valid_inputs=valid_inputs,
@@ -803,7 +805,7 @@ def create_function_derived_concept(
         purpose=purpose,
         lineage=Function(
             operator=operator,
-            arguments=arguments,
+            arguments=[x.reference for x in arguments],
             output_datatype=output_type,
             output_purpose=purpose,
             arg_count=len(arguments),
@@ -895,7 +897,7 @@ def Split(args: list[Concept], environment: Environment) -> Function:
     )
 
 
-def AttrAccess(args: list[GENERIC_ARGS], environment: Environment):
+def AttrAccess(args: list[ConceptRef | str | int], environment: Environment):
     return FunctionFactory(environment).create_function(
         args=args, operator=FunctionType.ATTR_ACCESS
     )

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/models/author.py

@@ -180,8 +180,14 @@ class UndefinedConcept(ConceptRef):
 
 def address_with_namespace(address: str, namespace: str) -> str:
     existing_ns = address.split(".", 1)[0]
+    if "." in address:
+        existing_name = address.split(".", 1)[1]
+    else:
+        existing_name = address
+    if existing_name == ALL_ROWS_CONCEPT:
+        return address
     if existing_ns == DEFAULT_NAMESPACE:
-        return f"{namespace}.{address.split('.',1)[1]}"
+        return f"{namespace}.{existing_name}"
     return f"{namespace}.{address}"
 
 
@@ -1129,7 +1135,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         return self.lineage.concept_arguments if self.lineage else []
 
     @classmethod
-    def calculate_derivation(self, lineage, purpose):
+    def calculate_derivation(self, lineage, purpose: Purpose) -> Derivation:
         from trilogy.core.models.build import (
             BuildAggregateWrapper,
             BuildFilterItem,
@@ -1598,9 +1604,6 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     ] = None
     arguments: Sequence[FuncArgs]
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     def __repr__(self):
         return f'{self.operator.value}({",".join([str(a) for a in self.arguments])})'
 

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/models/build.py

@@ -65,6 +65,7 @@ from trilogy.core.models.author import (
     RowsetLineage,
     SelectLineage,
     SubselectComparison,
+    UndefinedConcept,
     WhereClause,
     WindowItem,
 )
@@ -800,9 +801,6 @@ class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
     modifiers: List[Modifier] = Field(default_factory=list)  # type: ignore
     pseudonyms: set[str] = Field(default_factory=set)
 
-    def with_select_context(self, *args, **kwargs):
-        return self
-
     @property
     def is_aggregate(self) -> bool:
         return self.build_is_aggregate
@@ -1503,7 +1501,7 @@ class Factory:
         return base
 
     @build.register
-    def _(self, base: Function) -> BuildFunction:
+    def _(self, base: Function) -> BuildFunction | BuildAggregateWrapper:
         from trilogy.parsing.common import arbitrary_to_concept
 
         raw_args: list[Concept | FuncArgs] = []
@@ -1517,6 +1515,54 @@ class Factory:
                 raw_args.append(narg)
             else:
                 raw_args.append(arg)
+        if base.operator == FunctionType.GROUP:
+            group_base = raw_args[0]
+            final_args: List[Concept | ConceptRef] = []
+            if isinstance(group_base, ConceptRef):
+                if group_base.address in self.environment.concepts and not isinstance(
+                    self.environment.concepts[group_base.address], UndefinedConcept
+                ):
+                    group_base = self.environment.concepts[group_base.address]
+            if (
+                isinstance(group_base, Concept)
+                and isinstance(group_base.lineage, AggregateWrapper)
+                and not group_base.lineage.by
+            ):
+                arguments = raw_args[1:]
+                for x in arguments:
+                    if isinstance(x, (ConceptRef, Concept)):
+                        final_args.append(x)
+                    elif isinstance(x, (AggregateWrapper, FilterItem, WindowItem)):
+                        newx = arbitrary_to_concept(
+                            x,
+                            environment=self.environment,
+                        )
+                        final_args.append(newx)
+                    else:
+                        # constants, etc, can be ignored for group
+                        continue
+                group_base = group_base.model_copy(
+                    deep=True,
+                    update={
+                        "lineage": AggregateWrapper(
+                            function=group_base.lineage.function,
+                            by=final_args,
+                        )
+                    },
+                )
+                group_base = group_base.with_grain(
+                    Grain.from_concepts(final_args, environment=self.environment)
+                )
+                rval = self.build(group_base)
+                return BuildFunction.model_construct(
+                    operator=base.operator,
+                    arguments=[rval, *[self.build(c) for c in raw_args[1:]]],
+                    output_datatype=base.output_datatype,
+                    output_purpose=base.output_purpose,
+                    valid_inputs=base.valid_inputs,
+                    arg_count=base.arg_count,
+                )
+
         new = BuildFunction.model_construct(
             operator=base.operator,
             arguments=[self.build(c) for c in raw_args],
@@ -1568,7 +1614,10 @@ class Factory:
         new_lineage, final_grain, _ = base.get_select_grain_and_keys(
             self.grain, self.environment
         )
-        build_lineage = self.build(new_lineage)
+        if new_lineage:
+            build_lineage = self.build(new_lineage)
+        else:
+            build_lineage = None
         derivation = Concept.calculate_derivation(build_lineage, base.purpose)
         granularity = Concept.calculate_granularity(
             derivation, final_grain, build_lineage

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/models/environment.py

@@ -129,6 +129,9 @@ class EnvironmentConceptDict(dict):
     def __getitem__(
         self, key: str, line_no: int | None = None, file: Path | None = None
     ) -> Concept | UndefinedConceptFull:
+        # fast access path
+        if key in self.keys():
+            return super(EnvironmentConceptDict, self).__getitem__(key)
         if isinstance(key, ConceptRef):
             return self.__getitem__(key.address, line_no=line_no, file=file)
         try:
@@ -311,11 +314,15 @@ class Environment(BaseModel):
             f.write(self.model_dump_json())
         return ppath
 
-    def validate_concept(self, new_concept: Concept, meta: Meta | None = None):
+    def validate_concept(
+        self, new_concept: Concept, meta: Meta | None = None
+    ) -> Concept | None:
         lookup = new_concept.address
+        if lookup not in self.concepts:
+            return None
         existing: Concept = self.concepts.get(lookup)  # type: ignore
-        if not existing or isinstance(existing, UndefinedConcept):
-            return
+        if isinstance(existing, UndefinedConcept):
+            return None
 
         def handle_persist():
             deriv_lookup = (
@@ -361,7 +368,7 @@ class Environment(BaseModel):
         if existing and self.config.allow_duplicate_declaration:
             if existing.metadata.concept_source == ConceptSource.PERSIST_STATEMENT:
                 return handle_persist()
-            return
+            return None
         elif existing.metadata:
             if existing.metadata.concept_source == ConceptSource.PERSIST_STATEMENT:
                 return handle_persist()

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/processing/concept_strategies_v3.py

@@ -110,11 +110,14 @@ def get_priority_concept(
     depth: int,
 ) -> BuildConcept:
     # optimized search for missing concepts
-    pass_one = [
-        c
-        for c in all_concepts
-        if c.address not in attempted_addresses and c.address not in found_concepts
-    ]
+    pass_one = sorted(
+        [
+            c
+            for c in all_concepts
+            if c.address not in attempted_addresses and c.address not in found_concepts
+        ],
+        key=lambda x: x.address,
+    )
     # sometimes we need to scan intermediate concepts to get merge keys or filter keys,
     # so do an exhaustive search
     # pass_two = [c for c in all_concepts+filter_only if c.address not in attempted_addresses]
@@ -388,6 +391,9 @@ def generate_node(
                     # conditions=conditions,
                 )
             else:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} skipping search, already in a recursion fot these concepts"
+                )
                 return None
         return ConstantNode(
             input_concepts=[],
@@ -453,9 +459,10 @@ def generate_node(
                 f"{depth_to_prefix(depth)}{LOGGER_PREFIX} including any filters, there are non-root concepts we should expand first: {non_root}. Recursing with all of these as mandatory"
             )
 
-            if not history.check_started(
-                root_targets, accept_partial=accept_partial, conditions=conditions
-            ):
+            # if not history.check_started(
+            #     root_targets, accept_partial=accept_partial, conditions=conditions
+            # ) or 1==1:
+            if True:
                 history.log_start(
                     root_targets, accept_partial=accept_partial, conditions=conditions
                 )
@@ -470,7 +477,10 @@ def generate_node(
                     # which we do whenever we hit a root node
                     # conditions=conditions,
                 )
-
+            else:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} skipping root search, already in a recursion for these concepts"
+                )
         check = history.gen_select_node(
             concept,
             local_optional,
@@ -546,7 +556,10 @@ def generate_node(
                         f"{depth_to_prefix(depth)}{LOGGER_PREFIX} resolved concepts through synonyms"
                     )
                     return resolved
-
+            else:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} skipping synonym search, already in a recursion for these concepts"
+                )
             return None
     else:
         raise ValueError(f"Unknown derivation {concept.derivation} on {concept}")
@@ -1041,7 +1054,6 @@ def _search_concepts(
                 environment=environment,
                 depth=depth,
             )
-            logger.info(f"gcheck result is {result}")
             if result.required:
                 logger.info(
                     f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Adding group node"
@@ -1104,7 +1116,6 @@ def source_query_concepts(
         history=history,
         conditions=conditions,
     )
-
     if not root:
         error_strings = [
             f"{c.address}<{c.purpose}>{c.derivation}>" for c in output_concepts
@@ -1130,5 +1141,4 @@ def source_query_concepts(
         )
     else:
         candidate = root
-
     return candidate

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/processing/node_generators/filter_node.py

@@ -48,9 +48,10 @@ def gen_filter_node(
         if isinstance(x.lineage, FILTER_TYPES):
             if concept.lineage.where == where:
                 logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} fetching {x.lineage.content.address} as optional parent with same filter conditions "
+                    f"{padding(depth)}{LOGGER_PREFIX} fetching {x.lineage.content.address} as optional parent from optional {x} with same filter conditions "
                 )
-                parent_row_concepts.append(x.lineage.content)
+                if x.lineage.content.address not in parent_row_concepts:
+                    parent_row_concepts.append(x.lineage.content)
                 optional_included.append(x)
                 continue
         if conditions and conditions == where:

{pytrilogy-0.0.3.37 → pytrilogy-0.0.3.39}/trilogy/core/processing/node_generators/group_to_node.py

@@ -3,6 +3,8 @@ from typing import List
 from trilogy.constants import logger
 from trilogy.core.models.build import BuildConcept, BuildFunction, BuildWhereClause
 from trilogy.core.models.build_environment import BuildEnvironment
+
+# C:\Users\ethan\coding_projects\pytrilogy\trilogy\core\processing\node_generators\group_to_node.py
 from trilogy.core.processing.nodes import (
     GroupNode,
     History,
@@ -30,6 +32,7 @@ def gen_group_to_node(
             f"Group to should have function lineage, is {type(concept.lineage)}"
         )
     group_arg = concept.lineage.arguments[0]
+
     parent_concepts: List[BuildConcept] = concept.lineage.concept_arguments
     logger.info(
         f"{padding(depth)}{LOGGER_PREFIX} group by node has required parents {[x.address for x in parent_concepts]}"

pytrilogy-0.0.3.39/trilogy/core/processing/node_generators/union_node.py

@@ -0,0 +1,91 @@
+from typing import List
+
+from trilogy.constants import logger
+from trilogy.core.enums import FunctionType
+from trilogy.core.models.build import BuildConcept, BuildFunction, BuildWhereClause
+from trilogy.core.processing.nodes import History, StrategyNode, UnionNode
+from trilogy.core.processing.utility import padding
+
+LOGGER_PREFIX = "[GEN_UNION_NODE]"
+
+
+def is_union(c: BuildConcept):
+    return (
+        isinstance(c.lineage, BuildFunction)
+        and c.lineage.operator == FunctionType.UNION
+    )
+
+
+def build_layers(
+    concepts: list[BuildConcept],
+) -> tuple[list[list[BuildConcept]], list[BuildConcept]]:
+    sources = {
+        x.address: x.lineage.concept_arguments if x.lineage else [] for x in concepts
+    }
+    root = concepts[0]
+
+    built_layers = []
+    layers = root.lineage.concept_arguments if root.lineage else []
+    sourced = set()
+    while layers:
+        layer = []
+        current = layers.pop()
+        sourced.add(current.address)
+        layer.append(current)
+        for key, values in sources.items():
+            if key == current.address:
+                continue
+            for value in values:
+                if value.address in (current.keys or []) or current.address in (
+                    value.keys or []
+                ):
+                    layer.append(value)
+                    sourced.add(value.address)
+        built_layers.append(layer)
+    complete = [
+        x for x in concepts if all([x.address in sourced for x in sources[x.address]])
+    ]
+    return built_layers, complete
+
+
+def gen_union_node(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    environment,
+    g,
+    depth: int,
+    source_concepts,
+    history: History | None = None,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    all_unions = [x for x in local_optional if is_union(x)] + [concept]
+    logger.info(f"{padding(depth)}{LOGGER_PREFIX} found unions {all_unions}")
+    parent_nodes = []
+    layers, resolved = build_layers(all_unions)
+    for layer in layers:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} fetching layer {layer} with resolved {resolved}"
+        )
+        parent: StrategyNode = source_concepts(
+            mandatory_list=layer,
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
+            conditions=conditions,
+        )
+        parent.hide_output_concepts(parent.output_concepts)
+        parent.add_output_concepts(resolved)
+        parent_nodes.append(parent)
+        if not parent:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} could not find union node parents"
+            )
+            return None
+
+    return UnionNode(
+        input_concepts=resolved,
+        output_concepts=resolved,
+        environment=environment,
+        parents=parent_nodes,
+    )