pytrilogy 0.0.3.91__py3-none-any.whl → 0.0.3.93__py3-none-any.whl

trilogy/core/processing/node_generators/select_merge_node_v2.py

@@ -0,0 +1,792 @@
+from functools import lru_cache
+from typing import TYPE_CHECKING, Dict, List, Optional, Set
+
+import networkx as nx
+
+from trilogy.constants import logger
+from trilogy.core.enums import Derivation
+from trilogy.core.graph_models import (
+    concept_to_node,
+    get_graph_exact_match,
+    prune_sources_for_conditions,
+)
+from trilogy.core.models.build import (
+    BuildConcept,
+    BuildDatasource,
+    BuildGrain,
+    BuildWhereClause,
+    LooseBuildConceptList,
+)
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.processing.node_generators.select_helpers.datasource_injection import (
+    get_union_sources,
+)
+from trilogy.core.processing.nodes import (
+    ConstantNode,
+    GroupNode,
+    MergeNode,
+    SelectNode,
+    StrategyNode,
+)
+from trilogy.core.processing.utility import padding
+
+if TYPE_CHECKING:
+    from trilogy.core.processing.nodes.union_node import UnionNode
+
+LOGGER_PREFIX = "[GEN_ROOT_MERGE_NODE]"
+
+
+# Cache for expensive string operations
+@lru_cache(maxsize=1024)
+def extract_address(node: str) -> str:
+    """Cached version of address extraction from node string."""
+    return node.split("~")[1].split("@")[0]
+
+
+@lru_cache(maxsize=1024)
+def get_node_type(node: str) -> str:
+    """Extract node type prefix efficiently."""
+    if "~" in node:
+        return node.split("~")[0] + "~"
+    return ""
+
+
+class GraphAttributeCache:
+    """Cache for expensive NetworkX attribute operations."""
+
+    def __init__(self, graph: nx.DiGraph):
+        self.graph = graph
+        self._datasources: dict | None = None
+        self._concepts: dict | None = None
+        self._ds_nodes: set[str] | None = None
+        self._concept_nodes: set[str] | None = None
+
+    @property
+    def datasources(self) -> Dict:
+        if self._datasources is None:
+            self._datasources = nx.get_node_attributes(self.graph, "datasource") or {}
+        return self._datasources
+
+    @property
+    def concepts(self) -> Dict:
+        if self._concepts is None:
+            self._concepts = nx.get_node_attributes(self.graph, "concept") or {}
+        return self._concepts
+
+    @property
+    def ds_nodes(self) -> Set[str]:
+        if self._ds_nodes is None:
+            self._ds_nodes = {n for n in self.graph.nodes if n.startswith("ds~")}
+        return self._ds_nodes
+
+    @property
+    def concept_nodes(self) -> Set[str]:
+        if self._concept_nodes is None:
+            self._concept_nodes = {
+                n for n in self.graph.nodes if n.startswith("c~")
+            } or set()
+        return self._concept_nodes
+
+
+def get_graph_partial_nodes(
+    g: nx.DiGraph,
+    conditions: BuildWhereClause | None,
+    cache: GraphAttributeCache | None = None,
+) -> dict[str, list[str]]:
+    """Optimized version with caching and early returns."""
+    if cache is None:
+        cache = GraphAttributeCache(g)
+
+    datasources = cache.datasources
+    partial: dict[str, list[str]] = {}
+
+    for node in cache.ds_nodes:  # Only iterate over datasource nodes
+        if node not in datasources:
+            continue
+
+        ds = datasources[node]
+        if not isinstance(ds, list):
+            # Early return for non-partial nodes
+            if ds.non_partial_for and conditions == ds.non_partial_for:
+                partial[node] = []
+                continue
+            partial[node] = [concept_to_node(c) for c in ds.partial_concepts]
+        else:
+            # Union sources have no partial
+            partial[node] = []
+
+    return partial
+
+
+def get_graph_grains(
+    g: nx.DiGraph, cache: GraphAttributeCache | None = None
+) -> dict[str, set[str]]:
+    """Optimized version using set.update() instead of reduce with union."""
+    if cache is None:
+        cache = GraphAttributeCache(g)
+
+    datasources = cache.datasources
+    grain_length: dict[str, set[str]] = {}
+
+    for node in cache.ds_nodes:  # Only iterate over datasource nodes
+        if node not in datasources:
+            continue
+
+        lookup = datasources[node]
+        if not isinstance(lookup, list):
+            lookup = [lookup]
+
+        # Optimized set building - avoid reduce and intermediate sets
+        components: set[str] = set()
+        for item in lookup:
+            components.update(item.grain.components)
+        grain_length[node] = components
+
+    return grain_length
+
+
+def subgraph_is_complete(
+    nodes: list[str], targets: set[str], mapping: dict[str, str], g: nx.DiGraph
+) -> bool:
+    """Optimized with early returns and reduced iterations."""
+    # Early return check for target presence
+    mapped = set()
+    for n in nodes:
+        mapped.add(mapping.get(n, n))
+        # Early return if we've found all targets
+        if len(mapped) >= len(targets) and targets.issubset(mapped):
+            break
+
+    if not targets.issubset(mapped):
+        return False
+
+    # Check datasource edges more efficiently
+    has_ds_edge = {k: False for k in targets}
+
+    # Early return optimization - stop checking once all targets have edges
+    found_count = 0
+    for n in nodes:
+        if not n.startswith("c~"):
+            continue
+
+        concept_key = mapping.get(n, n)
+        if concept_key in has_ds_edge and not has_ds_edge[concept_key]:
+            # Check for datasource neighbor
+            for neighbor in nx.neighbors(g, n):
+                if neighbor.startswith("ds~"):
+                    has_ds_edge[concept_key] = True
+                    found_count += 1
+                    break
+
+            # Early return if all targets have datasource edges
+            if found_count == len(targets):
+                return True
+
+    return all(has_ds_edge.values())
+
+
+def create_pruned_concept_graph(
+    g: nx.DiGraph,
+    all_concepts: List[BuildConcept],
+    datasources: list[BuildDatasource],
+    accept_partial: bool = False,
+    conditions: BuildWhereClause | None = None,
+    depth: int = 0,
+) -> nx.DiGraph:
+    """Optimized version with caching and batch operations."""
+    orig_g = g
+    orig_cache = GraphAttributeCache(orig_g)
+
+    g = g.copy()
+    union_options = get_union_sources(datasources, all_concepts)
+
+    # Batch edge additions for union sources
+    edges_to_add = []
+    for ds_list in union_options:
+        node_address = "ds~" + "-".join([x.name for x in ds_list])
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} injecting potentially relevant union datasource {node_address}"
+        )
+        common: set[BuildConcept] = set.intersection(
+            *[set(x.output_concepts) for x in ds_list]
+        )
+        g.add_node(node_address, datasource=ds_list)
+
+        # Collect edges for batch addition
+        for c in common:
+            c_node = concept_to_node(c)
+            edges_to_add.extend([(node_address, c_node), (c_node, node_address)])
+
+    # Batch add all edges at once
+    if edges_to_add:
+        g.add_edges_from(edges_to_add)
+
+    prune_sources_for_conditions(g, accept_partial, conditions)
+
+    # Create cache for the modified graph
+    g_cache = GraphAttributeCache(g)
+
+    target_addresses = set([c.address for c in all_concepts])
+    concepts = orig_cache.concepts
+    datasource_map = orig_cache.datasources
+
+    # Optimized filtering with early termination
+    relevant_concepts_pre = {}
+    for n in g_cache.concept_nodes:  # Only iterate over concept nodes
+        if n in concepts:
+            concept = concepts[n]
+            if concept.address in target_addresses:
+                relevant_concepts_pre[n] = concept.address
+
+    relevant_concepts: list[str] = list(relevant_concepts_pre.keys())
+    relevent_datasets: list[str] = []
+
+    if not accept_partial:
+        partial = get_graph_partial_nodes(g, conditions, g_cache)
+        edges_to_remove = []
+
+        # Collect edges to remove
+        for edge in g.edges:
+            if edge[0] in datasource_map and edge[0] in partial:
+                if edge[1] in partial[edge[0]]:
+                    edges_to_remove.append(edge)
+            if edge[1] in datasource_map and edge[1] in partial:
+                if edge[0] in partial[edge[1]]:
+                    edges_to_remove.append(edge)
+
+        # Batch remove edges
+        if edges_to_remove:
+            g.remove_edges_from(edges_to_remove)
+
+    # Find relevant datasets more efficiently
+    relevant_concepts_set = set(relevant_concepts)
+    for n in g_cache.ds_nodes:  # Only iterate over datasource nodes
+        # Check if any relevant concepts are neighbors
+        if any(
+            neighbor in relevant_concepts_set for neighbor in nx.all_neighbors(g, n)
+        ):
+            relevent_datasets.append(n)
+
+    # Handle additional join concepts
+    roots: dict[str, set[str]] = {}
+    for n in orig_cache.concept_nodes:  # Only iterate over concept nodes
+        if n not in relevant_concepts:
+            root = n.split("@")[0]
+            neighbors = roots.get(root, set())
+            for neighbor in nx.all_neighbors(orig_g, n):
+                if neighbor in relevent_datasets:
+                    neighbors.add(neighbor)
+            if len(neighbors) > 1:
+                relevant_concepts.append(n)
+            roots[root] = neighbors
+
+    # Remove irrelevant nodes
+    nodes_to_keep = set(relevent_datasets + relevant_concepts)
+    nodes_to_remove = [n for n in g.nodes() if n not in nodes_to_keep]
+    if nodes_to_remove:
+        g.remove_nodes_from(nodes_to_remove)
+
+    # Check subgraphs
+    subgraphs = list(nx.connected_components(g.to_undirected()))
+    subgraphs = [
+        s
+        for s in subgraphs
+        if subgraph_is_complete(list(s), target_addresses, relevant_concepts_pre, g)
+    ]
+
+    if not subgraphs:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - no subgraphs after node prune"
+        )
+        return None
+
+    if subgraphs and len(subgraphs) != 1:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - subgraphs are split - have {len(subgraphs)} from {subgraphs}"
+        )
+        return None
+
+    # Add back relevant edges - batch operation
+    relevant = set(relevant_concepts + relevent_datasets)
+    edges_to_add = []
+    for edge in orig_g.edges():
+        if edge[0] in relevant and edge[1] in relevant and not g.has_edge(*edge):
+            edges_to_add.append(edge)
+    if edges_to_add:
+        g.add_edges_from(edges_to_add)
+
+    # Early return check
+    if not any(n.startswith("ds~") for n in g.nodes):
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - No datasource nodes found"
+        )
+        return None
+
+    return g
+
+
+def resolve_subgraphs(
+    g: nx.DiGraph,
+    relevant: list[BuildConcept],
+    accept_partial: bool,
+    conditions: BuildWhereClause | None,
+    depth: int = 0,
+) -> dict[str, list[str]]:
+    """Optimized version with caching and reduced iterations."""
+    cache = GraphAttributeCache(g)
+    datasources = list(cache.ds_nodes)
+
+    # Build subgraphs more efficiently
+    subgraphs: dict[str, list[str]] = {}
+    for ds in datasources:
+        # Use set to avoid duplicates from the start
+        subgraphs[ds] = list(set(nx.all_neighbors(g, ds)))
+
+    partial_map = get_graph_partial_nodes(g, conditions, cache)
+    exact_map = get_graph_exact_match(g, accept_partial, conditions)
+    grain_length = get_graph_grains(g, cache)
+    concepts = cache.concepts
+
+    # Pre-compute concept addresses for all datasources
+    non_partial_map = {}
+    concept_map = {}
+    for ds in datasources:
+        ds_concepts = subgraphs[ds]
+        partial_concepts = set(partial_map.get(ds, []))
+
+        non_partial_map[ds] = [
+            concepts[c].address
+            for c in ds_concepts
+            if c in concepts and c not in partial_concepts
+        ]
+        concept_map[ds] = [concepts[c].address for c in ds_concepts if c in concepts]
+
+    pruned_subgraphs = {}
+
+    def score_node(input: str) -> tuple:
+        """Optimized scoring function."""
+        logger.debug(f"{padding(depth)}{LOGGER_PREFIX} scoring node {input}")
+        grain = grain_length[input]
+        concept_addresses = concept_map[input]
+
+        # Calculate score components
+        grain_score = len(grain) - sum(1 for x in concept_addresses if x in grain)
+        exact_match_score = 0 if input in exact_map else 0.5
+        concept_count = len(subgraphs[input])
+
+        score = (grain_score, exact_match_score, concept_count, input)
+        logger.debug(f"{padding(depth)}{LOGGER_PREFIX} node {input} has score {score}")
+        return score
+
+    # Optimize subset detection with early termination
+    for key in subgraphs:
+        value = non_partial_map[key]
+        all_concepts = concept_map[key]
+        is_subset = False
+        matches = set()
+
+        # Early termination optimization
+        value_set = set(value)
+        all_concepts_set = set(all_concepts)
+
+        for other_key in concept_map:
+            if key == other_key:
+                continue
+
+            other_value = non_partial_map[other_key]
+            other_all_concepts = concept_map[other_key]
+
+            # Quick check before detailed comparison
+            if len(value) > len(other_value) or len(all_concepts) > len(
+                other_all_concepts
+            ):
+                continue
+
+            other_value_set = set(other_value)
+            other_all_concepts_set = set(other_all_concepts)
+
+            if value_set.issubset(other_value_set) and all_concepts_set.issubset(
+                other_all_concepts_set
+            ):
+                if len(value) < len(other_value):
+                    is_subset = True
+                    logger.debug(
+                        f"{padding(depth)}{LOGGER_PREFIX} Dropping subgraph {key} with {value} as it is a subset of {other_key} with {other_value}"
+                    )
+                    break  # Early termination
+                elif len(value) == len(other_value) and len(all_concepts) == len(
+                    other_all_concepts
+                ):
+                    matches.add(other_key)
+                    matches.add(key)
+
+        if matches and not is_subset:
+            min_node = min(matches, key=score_node)
+            logger.debug(
+                f"{padding(depth)}{LOGGER_PREFIX} minimum source score is {min_node}"
+            )
+            is_subset = key != min_node
+
+        if not is_subset:
+            pruned_subgraphs[key] = subgraphs[key]
+
+    # Final node pruning - optimized
+    final_nodes: set[str] = set()
+    for v in pruned_subgraphs.values():
+        final_nodes.update(v)
+
+    relevant_concepts_pre = {
+        n: concepts[n].address
+        for n in cache.concept_nodes
+        if n in concepts and concepts[n].address in relevant
+    }
+
+    # Count node occurrences once
+    node_counts = {}
+    for node in final_nodes:
+        if node.startswith("c~") and node not in relevant_concepts_pre:
+            node_counts[node] = sum(
+                1 for sub_nodes in pruned_subgraphs.values() if node in sub_nodes
+            )
+
+    # Filter nodes based on counts
+    nodes_to_remove = {node for node, count in node_counts.items() if count <= 1}
+
+    if nodes_to_remove:
+        for key in pruned_subgraphs:
+            pruned_subgraphs[key] = [
+                n for n in pruned_subgraphs[key] if n not in nodes_to_remove
+            ]
+            logger.debug(
+                f"{padding(depth)}{LOGGER_PREFIX} Pruning nodes {nodes_to_remove} as irrelevant after subgraph resolution"
+            )
+
+    return pruned_subgraphs
+
+
+def create_datasource_node(
+    datasource: BuildDatasource,
+    all_concepts: List[BuildConcept],
+    accept_partial: bool,
+    environment: BuildEnvironment,
+    depth: int,
+    conditions: BuildWhereClause | None = None,
+) -> tuple[StrategyNode, bool]:
+
+    target_grain = BuildGrain.from_concepts(all_concepts, environment=environment)
+    force_group = False
+    if not datasource.grain.issubset(target_grain):
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX}_DS_NODE Select node must be wrapped in group, {datasource.grain} not subset of target grain {target_grain}"
+        )
+        force_group = True
+    else:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX}_DS_NODE Select node grain {datasource.grain} is subset of target grain {target_grain}, no group required"
+        )
+    if not datasource.grain.components:
+        force_group = True
+
+    # Optimized concept filtering using sets
+    all_concept_addresses = {c.address for c in all_concepts}
+
+    partial_concepts = [
+        c.concept
+        for c in datasource.columns
+        if not c.is_complete and c.concept.address in all_concept_addresses
+    ]
+
+    partial_lcl = LooseBuildConceptList(concepts=partial_concepts)
+
+    nullable_concepts = [
+        c.concept
+        for c in datasource.columns
+        if c.is_nullable and c.concept.address in all_concept_addresses
+    ]
+
+    nullable_lcl = LooseBuildConceptList(concepts=nullable_concepts)
+    partial_is_full = conditions and (conditions == datasource.non_partial_for)
+
+    datasource_conditions = datasource.where.conditional if datasource.where else None
+    rval = SelectNode(
+        input_concepts=[c.concept for c in datasource.columns],
+        output_concepts=sorted(all_concepts, key=lambda x: x.address),
+        environment=environment,
+        parents=[],
+        depth=depth,
+        partial_concepts=(
+            [] if partial_is_full else [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=datasource.grain,
+        conditions=datasource_conditions,
+        preexisting_conditions=(
+            conditions.conditional if partial_is_full and conditions else None
+        ),
+    )
+    return (
+        rval,
+        force_group,
+    )
+
+
+def create_union_datasource(
+    datasource: list[BuildDatasource],
+    all_concepts: List[BuildConcept],
+    accept_partial: bool,
+    environment: BuildEnvironment,
+    depth: int,
+    conditions: BuildWhereClause | None = None,
+) -> tuple["UnionNode", bool]:
+    from trilogy.core.processing.nodes.union_node import UnionNode
+
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} generating union node parents with condition {conditions}"
+    )
+    force_group = False
+    parents = []
+    for x in datasource:
+        subnode, fg = create_datasource_node(
+            x,
+            all_concepts,
+            accept_partial,
+            environment,
+            depth + 1,
+            conditions=conditions,
+        )
+        parents.append(subnode)
+        force_group = force_group or fg
+    logger.info(f"{padding(depth)}{LOGGER_PREFIX} returning union node")
+    return (
+        UnionNode(
+            output_concepts=all_concepts,
+            input_concepts=all_concepts,
+            environment=environment,
+            parents=parents,
+            depth=depth,
+            partial_concepts=[],
+        ),
+        force_group,
+    )
+
+
+def create_select_node(
+    ds_name: str,
+    subgraph: list[str],
+    accept_partial: bool,
+    g,
+    environment: BuildEnvironment,
+    depth: int,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode:
+
+    # Use cached extraction
+    all_concepts = [
+        environment.concepts[extract_address(c)] for c in subgraph if c.startswith("c~")
+    ]
+
+    # Early return for all constants
+    if all(c.derivation == Derivation.CONSTANT for c in all_concepts):
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} All concepts {[x.address for x in all_concepts]} are constants, returning constant node"
+        )
+        return ConstantNode(
+            output_concepts=all_concepts,
+            input_concepts=[],
+            environment=environment,
+            parents=[],
+            depth=depth,
+            partial_concepts=[],
+            force_group=False,
+            preexisting_conditions=conditions.conditional if conditions else None,
+        )
+
+    cache = GraphAttributeCache(g)
+    datasource = cache.datasources[ds_name]
+
+    if isinstance(datasource, BuildDatasource):
+        bcandidate, force_group = create_datasource_node(
+            datasource,
+            all_concepts,
+            accept_partial,
+            environment,
+            depth,
+            conditions=conditions,
+        )
+
+    elif isinstance(datasource, list):
+        bcandidate, force_group = create_union_datasource(
+            datasource,
+            all_concepts,
+            accept_partial,
+            environment,
+            depth,
+            conditions=conditions,
+        )
+    else:
+        raise ValueError(f"Unknown datasource type {datasource}")
+
+    # we need to nest the group node one further
+    if force_group is True:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} source requires group before consumption."
+        )
+        candidate: StrategyNode = GroupNode(
+            output_concepts=all_concepts,
+            input_concepts=all_concepts,
+            environment=environment,
+            parents=[bcandidate],
+            depth=depth + 1,
+            partial_concepts=bcandidate.partial_concepts,
+            nullable_concepts=bcandidate.nullable_concepts,
+            preexisting_conditions=bcandidate.preexisting_conditions,
+            force_group=force_group,
+        )
+    else:
+        candidate = bcandidate
+
+    return candidate
+
+
+def gen_select_merge_node(
+    all_concepts: List[BuildConcept],
+    g: nx.DiGraph,
+    environment: BuildEnvironment,
+    depth: int,
+    accept_partial: bool = False,
+    conditions: BuildWhereClause | None = None,
+) -> Optional[StrategyNode]:
+    # Early separation of constants and non-constants
+    non_constant = []
+    constants = []
+    for c in all_concepts:
+        if c.derivation == Derivation.CONSTANT:
+            constants.append(c)
+        else:
+            non_constant.append(c)
+
+    # Early return for all constants
+    if not non_constant and constants:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} only constant inputs to discovery ({constants}), returning constant node directly"
+        )
+        for x in constants:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} {x} {x.lineage} {x.derivation}"
+            )
+        if conditions:
+            if not all(
+                x.derivation == Derivation.CONSTANT for x in conditions.row_arguments
+            ):
+                logger.info(
+                    f"{padding(depth)}{LOGGER_PREFIX} conditions being passed in to constant node {conditions}, but not all concepts are constants."
+                )
+                return None
+            else:
+                constants += conditions.row_arguments
+
+        return ConstantNode(
+            output_concepts=constants,
+            input_concepts=[],
+            environment=environment,
+            parents=[],
+            depth=depth,
+            partial_concepts=[],
+            force_group=False,
+            conditions=conditions.conditional if conditions else None,
+        )
+
+    attempts = [False]
+    if accept_partial:
+        attempts.append(True)
+
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} searching for root source graph for concepts {[c.address for c in all_concepts]} and conditions {conditions}"
+    )
+
+    pruned_concept_graph = None
+    for attempt in attempts:
+        pruned_concept_graph = create_pruned_concept_graph(
+            g,
+            non_constant,
+            accept_partial=attempt,
+            conditions=conditions,
+            datasources=list(environment.datasources.values()),
+            depth=depth,
+        )
+        if pruned_concept_graph:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} found covering graph w/ partial flag {attempt}"
+            )
+            break
+
+    if not pruned_concept_graph:
+        logger.info(f"{padding(depth)}{LOGGER_PREFIX} no covering graph found.")
+        return None
+
+    sub_nodes = resolve_subgraphs(
+        pruned_concept_graph,
+        relevant=non_constant,
+        accept_partial=accept_partial,
+        conditions=conditions,
+        depth=depth,
+    )
+
+    logger.info(f"{padding(depth)}{LOGGER_PREFIX} fetching subgraphs {sub_nodes}")
+
+    parents = [
+        create_select_node(
+            k,
+            subgraph,
+            g=pruned_concept_graph,
+            accept_partial=accept_partial,
+            environment=environment,
+            depth=depth,
+            conditions=conditions,
+        )
+        for k, subgraph in sub_nodes.items()
+    ]
+
+    if not parents:
+        return None
+
+    if constants:
+        parents.append(
+            ConstantNode(
+                output_concepts=constants,
+                input_concepts=[],
+                environment=environment,
+                parents=[],
+                depth=depth,
+                partial_concepts=[],
+                force_group=False,
+                preexisting_conditions=conditions.conditional if conditions else None,
+            )
+        )
+
+    if len(parents) == 1:
+        return parents[0]
+
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} Multiple parent DS nodes resolved - {[type(x) for x in parents]}, wrapping in merge"
+    )
+
+    preexisting_conditions = None
+    if conditions and all(
+        x.preexisting_conditions and x.preexisting_conditions == conditions.conditional
+        for x in parents
+    ):
+        preexisting_conditions = conditions.conditional
+
+    base = MergeNode(
+        output_concepts=all_concepts,
+        input_concepts=non_constant,
+        environment=environment,
+        depth=depth,
+        parents=parents,
+        preexisting_conditions=preexisting_conditions,
+    )
+
+    return base