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

trilogy/core/models/build.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from abc import ABC
 from collections import defaultdict
+from dataclasses import dataclass, field
 from datetime import date, datetime
 from functools import cached_property, singledispatchmethod
 from typing import (
@@ -18,12 +19,7 @@ from typing import (
 )
 
 from pydantic import (
-    BaseModel,
     ConfigDict,
-    Field,
-    ValidationInfo,
-    computed_field,
-    field_validator,
 )
 
 from trilogy.constants import DEFAULT_NAMESPACE, MagicConstants
@@ -93,7 +89,6 @@ from trilogy.core.models.datasource import (
     RawColumnExpr,
 )
 from trilogy.core.models.environment import Environment
-from trilogy.utility import unique
 
 # TODO: refactor to avoid these
 if TYPE_CHECKING:
@@ -149,8 +144,8 @@ def concept_is_relevant(
 
 def concepts_to_build_grain_concepts(
     concepts: Iterable[BuildConcept | str], environment: "BuildEnvironment" | None
-) -> list[BuildConcept]:
-    pconcepts = []
+) -> set[str]:
+    pconcepts: list[BuildConcept] = []
     for c in concepts:
         if isinstance(c, BuildConcept):
             pconcepts.append(c)
@@ -162,27 +157,23 @@ def concepts_to_build_grain_concepts(
                 f"Unable to resolve input {c} without environment provided to concepts_to_grain call"
             )
 
-    final: List[BuildConcept] = []
+    final: set[str] = set()
     for sub in pconcepts:
         if not concept_is_relevant(sub, pconcepts):
             continue
-        final.append(sub)
-    final = unique(final, "address")
-    v2 = sorted(final, key=lambda x: x.name)
-    return v2
+        final.add(sub.address)
 
+    return final
 
-class LooseBuildConceptList(BaseModel):
+
+@dataclass
+class LooseBuildConceptList:
     concepts: Sequence[BuildConcept]
 
     @cached_property
     def addresses(self) -> set[str]:
         return {s.address for s in self.concepts}
 
-    @classmethod
-    def validate(cls, v):
-        return cls(v)
-
     @cached_property
     def sorted_addresses(self) -> List[str]:
         return sorted(list(self.addresses))
@@ -250,7 +241,8 @@ def get_concept_arguments(expr) -> List["BuildConcept"]:
     return output
 
 
-class BuildParamaterizedConceptReference(DataTyped, BaseModel):
+@dataclass
+class BuildParamaterizedConceptReference(DataTyped):
     concept: BuildConcept
 
     def __str__(self):
@@ -265,12 +257,17 @@ class BuildParamaterizedConceptReference(DataTyped, BaseModel):
         return self.concept.output_datatype
 
 
-class BuildGrain(BaseModel):
-    components: set[str] = Field(default_factory=set)
+@dataclass
+class BuildGrain:
+    components: set[str] = field(default_factory=set)
     where_clause: Optional[BuildWhereClause] = None
+    _str: str | None = None
+    _str_no_condition: str | None = None
 
     def without_condition(self):
-        return BuildGrain.model_construct(components=self.components)
+        if not self.where_clause:
+            return self
+        return BuildGrain(components=self.components)
 
     @classmethod
     def from_concepts(
@@ -281,32 +278,12 @@ class BuildGrain(BaseModel):
     ) -> "BuildGrain":
 
         return BuildGrain(
-            components={
-                c.address
-                for c in concepts_to_build_grain_concepts(
-                    concepts, environment=environment
-                )
-            },
+            components=concepts_to_build_grain_concepts(
+                concepts, environment=environment
+            ),
             where_clause=where_clause,
         )
 
-    @field_validator("components", mode="before")
-    def component_validator(cls, v, info: ValidationInfo):
-        output = set()
-        if isinstance(v, list):
-            for vc in v:
-                if isinstance(vc, BuildConcept):
-                    output.add(vc.address)
-                else:
-                    output.add(vc)
-        else:
-            output = v
-        if not isinstance(output, set):
-            raise ValueError(f"Invalid grain component {output}, is not set")
-        if not all(isinstance(x, str) for x in output):
-            raise ValueError(f"Invalid component {output}")
-        return output
-
     def __add__(self, other: "BuildGrain") -> "BuildGrain":
         if not other:
             return self
@@ -325,12 +302,12 @@ class BuildGrain(BaseModel):
                 # raise NotImplementedError(
                 #     f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
                 # )
-        return BuildGrain.model_construct(
+        return BuildGrain(
             components=self.components.union(other.components), where_clause=where
         )
 
     def __sub__(self, other: "BuildGrain") -> "BuildGrain":
-        return BuildGrain.model_construct(
+        return BuildGrain(
             components=self.components.difference(other.components),
             where_clause=self.where_clause,
         )
@@ -366,15 +343,35 @@ class BuildGrain(BaseModel):
         intersection = self.components.intersection(other.components)
         return BuildGrain(components=intersection)
 
-    def __str__(self):
+    def _calculate_string(self):
         if self.abstract:
             base = "Grain<Abstract>"
         else:
-            base = "Grain<" + ",".join([c for c in sorted(list(self.components))]) + ">"
+            base = "Grain<" + ",".join(sorted(self.components)) + ">"
         if self.where_clause:
             base += f"|{str(self.where_clause)}"
         return base
 
+    def _calculate_string_no_condition(self):
+        if self.abstract:
+            base = "Grain<Abstract>"
+        else:
+            base = "Grain<" + ",".join(sorted(self.components)) + ">"
+        return base
+
+    @property
+    def str_no_condition(self):
+        if self._str_no_condition:
+            return self._str_no_condition
+        self._str_no_condition = self._calculate_string_no_condition()
+        return self._str_no_condition
+
+    def __str__(self):
+        if self._str:
+            return self._str
+        self._str = self._calculate_string()
+        return self._str
+
     def __radd__(self, other) -> "BuildGrain":
         if other == 0:
             return self
@@ -382,7 +379,8 @@ class BuildGrain(BaseModel):
             return self.__add__(other)
 
 
-class BuildParenthetical(DataTyped, ConstantInlineable, BuildConceptArgs, BaseModel):
+@dataclass
+class BuildParenthetical(DataTyped, ConstantInlineable, BuildConceptArgs):
     content: "BuildExpr"
 
     def __add__(self, other) -> Union["BuildParenthetical", "BuildConditional"]:
@@ -436,7 +434,8 @@ class BuildParenthetical(DataTyped, ConstantInlineable, BuildConceptArgs, BaseMo
         return arg_to_datatype(self.content)
 
 
-class BuildConditional(BuildConceptArgs, ConstantInlineable, BaseModel):
+@dataclass
+class BuildConditional(BuildConceptArgs, ConstantInlineable):
     left: Union[
         int,
         str,
@@ -564,7 +563,8 @@ class BuildConditional(BuildConceptArgs, ConstantInlineable, BaseModel):
         return chunks
 
 
-class BuildWhereClause(BuildConceptArgs, BaseModel):
+@dataclass
+class BuildWhereClause(BuildConceptArgs):
     conditional: Union[
         BuildSubselectComparison,
         BuildComparison,
@@ -600,7 +600,8 @@ class BuildHavingClause(BuildWhereClause):
     pass
 
 
-class BuildComparison(BuildConceptArgs, ConstantInlineable, BaseModel):
+@dataclass
+class BuildComparison(BuildConceptArgs, ConstantInlineable):
 
     left: Union[
         int,
@@ -730,6 +731,7 @@ class BuildComparison(BuildConceptArgs, ConstantInlineable, BaseModel):
         return output
 
 
+@dataclass
 class BuildSubselectComparison(BuildComparison):
     left: Union[
         int,
@@ -791,18 +793,18 @@ class BuildSubselectComparison(BuildComparison):
         return [tuple(get_concept_arguments(self.right))]
 
 
-class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
+@dataclass
+class BuildConcept(Addressable, BuildConceptArgs, DataTyped):
     model_config = ConfigDict(extra="forbid")
     name: str
-    datatype: DataType | ArrayType | StructType | MapType | NumericType
+    datatype: DataType | ArrayType | StructType | MapType | NumericType | TraitDataType
     purpose: Purpose
     build_is_aggregate: bool
     derivation: Derivation = Derivation.ROOT
     granularity: Granularity = Granularity.MULTI_ROW
-    namespace: Optional[str] = Field(default=DEFAULT_NAMESPACE, validate_default=True)
-    metadata: Metadata = Field(
+    namespace: Optional[str] = field(default=DEFAULT_NAMESPACE)
+    metadata: Metadata = field(
         default_factory=lambda: Metadata(description=None, line_number=None),
-        validate_default=True,
     )
     lineage: Optional[
         Union[
@@ -816,22 +818,23 @@ class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
     ] = None
 
     keys: Optional[set[str]] = None
-    grain: BuildGrain = Field(default=None, validate_default=True)  # type: ignore
-    modifiers: List[Modifier] = Field(default_factory=list)  # type: ignore
-    pseudonyms: set[str] = Field(default_factory=set)
+    grain: BuildGrain = field(default=None)  # type: ignore
+    modifiers: List[Modifier] = field(default_factory=list)  # type: ignore
+    pseudonyms: set[str] = field(default_factory=set)
 
     @property
     def is_aggregate(self) -> bool:
         return self.build_is_aggregate
 
-    def duplicate(self) -> BuildConcept:
-        return self.model_copy(deep=True)
-
-    def __hash__(self):
+    @cached_property
+    def hash(self) -> int:
         return hash(
             f"{self.name}+{self.datatype}+ {self.purpose} + {str(self.lineage)} + {self.namespace} + {str(self.grain)} + {str(self.keys)}"
         )
 
+    def __hash__(self):
+        return self.hash
+
     def __repr__(self):
         base = f"{self.address}@{self.grain}"
         return base
@@ -884,7 +887,7 @@ class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
                     ]
                 )
             )
-        return self.__class__.model_construct(
+        return self.__class__(
             name=self.name,
             datatype=self.datatype,
             purpose=self.purpose,
@@ -926,7 +929,7 @@ class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
                 grain = self.grain
         else:
             grain = self.grain  # type: ignore
-        return self.__class__.model_construct(
+        return self.__class__(
             name=self.name,
             datatype=self.datatype,
             purpose=self.purpose,
@@ -982,7 +985,8 @@ class BuildConcept(Addressable, BuildConceptArgs, DataTyped, BaseModel):
         return self.lineage.concept_arguments if self.lineage else []
 
 
-class BuildOrderItem(DataTyped, BuildConceptArgs, BaseModel):
+@dataclass
+class BuildOrderItem(DataTyped, BuildConceptArgs):
     expr: BuildExpr
     order: Ordering
 
@@ -1013,11 +1017,12 @@ class BuildOrderItem(DataTyped, BuildConceptArgs, BaseModel):
         return arg_to_datatype(self.expr)
 
 
-class BuildWindowItem(DataTyped, BuildConceptArgs, BaseModel):
+@dataclass
+class BuildWindowItem(DataTyped, BuildConceptArgs):
     type: WindowType
     content: BuildConcept
     order_by: List[BuildOrderItem]
-    over: List["BuildConcept"] = Field(default_factory=list)
+    over: List["BuildConcept"] = field(default_factory=list)
     index: Optional[int] = None
 
     def __repr__(self) -> str:
@@ -1050,7 +1055,8 @@ class BuildWindowItem(DataTyped, BuildConceptArgs, BaseModel):
         return Purpose.PROPERTY
 
 
-class BuildCaseWhen(BuildConceptArgs, BaseModel):
+@dataclass
+class BuildCaseWhen(BuildConceptArgs):
     comparison: BuildConditional | BuildSubselectComparison | BuildComparison
     expr: "BuildExpr"
 
@@ -1071,30 +1077,18 @@ class BuildCaseWhen(BuildConceptArgs, BaseModel):
         )
 
 
-class BuildCaseElse(BuildConceptArgs, BaseModel):
+@dataclass
+class BuildCaseElse(BuildConceptArgs):
     expr: "BuildExpr"
-    # this ensures that it's easily differentiable from CaseWhen
-    discriminant: ComparisonOperator = ComparisonOperator.ELSE
 
     @property
     def concept_arguments(self):
         return get_concept_arguments(self.expr)
 
 
-class BuildFunction(DataTyped, BuildConceptArgs, BaseModel):
-    # class BuildFunction(Function):
+@dataclass
+class BuildFunction(DataTyped, BuildConceptArgs):
     operator: FunctionType
-    arg_count: int = Field(default=1)
-    output_datatype: (
-        DataType | ArrayType | StructType | MapType | NumericType | TraitDataType
-    )
-    output_purpose: Purpose
-    valid_inputs: Optional[
-        Union[
-            Set[DataType],
-            List[Set[DataType]],
-        ]
-    ] = None
     arguments: Sequence[
         Union[
             int,
@@ -1120,6 +1114,17 @@ class BuildFunction(DataTyped, BuildConceptArgs, BaseModel):
             ListWrapper[Any],
         ]
     ]
+    output_data_type: (
+        DataType | ArrayType | StructType | MapType | NumericType | TraitDataType
+    )
+    output_purpose: Purpose = field(default=Purpose.KEY)
+    arg_count: int = field(default=1)
+    valid_inputs: Optional[
+        Union[
+            Set[DataType],
+            List[Set[DataType]],
+        ]
+    ] = None
 
     def __repr__(self):
         return f'{self.operator.value}({",".join([str(a) for a in self.arguments])})'
@@ -1129,7 +1134,11 @@ class BuildFunction(DataTyped, BuildConceptArgs, BaseModel):
 
     @property
     def datatype(self):
-        return self.output_datatype
+        return self.output_data_type
+
+    @property
+    def output_datatype(self):
+        return self.output_data_type
 
     @property
     def concept_arguments(self) -> List[BuildConcept]:
@@ -1141,18 +1150,19 @@ class BuildFunction(DataTyped, BuildConceptArgs, BaseModel):
     @property
     def output_grain(self):
         # aggregates have an abstract grain
-        base_grain = BuildGrain(components=[])
         if self.operator in FunctionClass.AGGREGATE_FUNCTIONS.value:
-            return base_grain
+            return BuildGrain(components=[])
         # scalars have implicit grain of all arguments
+        args = set()
         for input in self.concept_arguments:
-            base_grain += input.grain
-        return base_grain
+            args += input.grain.components
+        return BuildGrain(components=args)
 
 
-class BuildAggregateWrapper(BuildConceptArgs, DataTyped, BaseModel):
+@dataclass
+class BuildAggregateWrapper(BuildConceptArgs, DataTyped):
     function: BuildFunction
-    by: List[BuildConcept] = Field(default_factory=list)
+    by: List[BuildConcept] = field(default_factory=list)
 
     def __str__(self):
         grain_str = [str(c) for c in self.by] if self.by else "abstract"
@@ -1175,7 +1185,8 @@ class BuildAggregateWrapper(BuildConceptArgs, DataTyped, BaseModel):
         return self.function.output_purpose
 
 
-class BuildFilterItem(BuildConceptArgs, BaseModel):
+@dataclass
+class BuildFilterItem(BuildConceptArgs):
     content: "BuildExpr"
     where: BuildWhereClause
 
@@ -1207,13 +1218,15 @@ class BuildFilterItem(BuildConceptArgs, BaseModel):
         return self.where.concept_arguments
 
 
-class BuildRowsetLineage(BuildConceptArgs, BaseModel):
+@dataclass
+class BuildRowsetLineage(BuildConceptArgs):
     name: str
     derived_concepts: List[str]
     select: SelectLineage | MultiSelectLineage
 
 
-class BuildRowsetItem(DataTyped, BuildConceptArgs, BaseModel):
+@dataclass
+class BuildRowsetItem(DataTyped, BuildConceptArgs):
     content: BuildConcept
     rowset: BuildRowsetLineage
 
@@ -1240,7 +1253,8 @@ class BuildRowsetItem(DataTyped, BuildConceptArgs, BaseModel):
         return [self.content]
 
 
-class BuildOrderBy(BaseModel):
+@dataclass
+class BuildOrderBy:
     items: List[BuildOrderItem]
 
     @property
@@ -1248,39 +1262,42 @@ class BuildOrderBy(BaseModel):
         return [x.expr for x in self.items]
 
 
-class BuildAlignClause(BaseModel):
+@dataclass
+class BuildAlignClause:
     items: List[BuildAlignItem]
 
 
-class BuildSelectLineage(BaseModel):
+@dataclass
+class BuildSelectLineage:
     selection: List[BuildConcept]
     hidden_components: set[str]
     local_concepts: dict[str, BuildConcept]
     order_by: Optional[BuildOrderBy] = None
     limit: Optional[int] = None
-    meta: Metadata = Field(default_factory=lambda: Metadata())
-    grain: BuildGrain = Field(default_factory=BuildGrain)
-    where_clause: BuildWhereClause | None = Field(default=None)
-    having_clause: BuildHavingClause | None = Field(default=None)
+    meta: Metadata = field(default_factory=lambda: Metadata())
+    grain: BuildGrain = field(default_factory=BuildGrain)
+    where_clause: BuildWhereClause | None = field(default=None)
+    having_clause: BuildHavingClause | None = field(default=None)
 
     @property
     def output_components(self) -> List[BuildConcept]:
         return self.selection
 
 
-class BuildMultiSelectLineage(BuildConceptArgs, BaseModel):
+@dataclass
+class BuildMultiSelectLineage(BuildConceptArgs):
     selects: List[SelectLineage]
     grain: BuildGrain
     align: BuildAlignClause
     namespace: str
-    order_by: Optional[BuildOrderBy] = None
-    limit: Optional[int] = None
-    where_clause: Union["BuildWhereClause", None] = Field(default=None)
-    having_clause: Union["BuildHavingClause", None] = Field(default=None)
     local_concepts: dict[str, BuildConcept]
     build_concept_arguments: list[BuildConcept]
     build_output_components: list[BuildConcept]
     hidden_components: set[str]
+    order_by: Optional[BuildOrderBy] = None
+    limit: Optional[int] = None
+    where_clause: Union["BuildWhereClause", None] = field(default=None)
+    having_clause: Union["BuildHavingClause", None] = field(default=None)
 
     @property
     def derived_concepts(self) -> set[str]:
@@ -1322,12 +1339,12 @@ class BuildMultiSelectLineage(BuildConceptArgs, BaseModel):
         )
 
 
-class BuildAlignItem(BaseModel):
+@dataclass
+class BuildAlignItem:
     alias: str
     concepts: List[BuildConcept]
-    namespace: str = Field(default=DEFAULT_NAMESPACE, validate_default=True)
+    namespace: str = field(default=DEFAULT_NAMESPACE)
 
-    @computed_field  # type: ignore
     @cached_property
     def concepts_lcl(self) -> LooseBuildConceptList:
         return LooseBuildConceptList(concepts=self.concepts)
@@ -1337,10 +1354,11 @@ class BuildAlignItem(BaseModel):
         return f"{self.namespace}.{self.alias}"
 
 
-class BuildColumnAssignment(BaseModel):
-    alias: str | RawColumnExpr | BuildFunction
+@dataclass
+class BuildColumnAssignment:
+    alias: str | RawColumnExpr | BuildFunction | BuildAggregateWrapper
     concept: BuildConcept
-    modifiers: List[Modifier] = Field(default_factory=list)
+    modifiers: List[Modifier] = field(default_factory=list)
 
     @property
     def is_complete(self) -> bool:
@@ -1351,15 +1369,16 @@ class BuildColumnAssignment(BaseModel):
         return Modifier.NULLABLE in self.modifiers
 
 
-class BuildDatasource(BaseModel):
+@dataclass
+class BuildDatasource:
     name: str
     columns: List[BuildColumnAssignment]
     address: Union[Address, str]
-    grain: BuildGrain = Field(
-        default_factory=lambda: BuildGrain(components=set()), validate_default=True
+    grain: BuildGrain = field(
+        default_factory=lambda: BuildGrain(components=set()),
     )
-    namespace: Optional[str] = Field(default=DEFAULT_NAMESPACE, validate_default=True)
-    metadata: DatasourceMetadata = Field(
+    namespace: Optional[str] = field(default=DEFAULT_NAMESPACE)
+    metadata: DatasourceMetadata = field(
         default_factory=lambda: DatasourceMetadata(freshness_concept=None)
     )
     where: Optional[BuildWhereClause] = None
@@ -1428,7 +1447,7 @@ class BuildDatasource(BaseModel):
         concept: BuildConcept,
         use_raw_name: bool = True,
         force_alias: bool = False,
-    ) -> Optional[str | RawColumnExpr] | BuildFunction:
+    ) -> Optional[str | RawColumnExpr] | BuildFunction | BuildAggregateWrapper:
         # 2022-01-22
         # this logic needs to be refined.
         # if concept.lineage:
@@ -1472,8 +1491,6 @@ BuildExpr = (
     | list
 )
 
-BuildConcept.model_rebuild()
-
 
 def get_canonical_pseudonyms(environment: Environment) -> dict[str, set[str]]:
     roots: dict[str, set[str]] = defaultdict(set)
@@ -1507,13 +1524,15 @@ class Factory:
         environment: Environment,
         local_concepts: dict[str, BuildConcept] | None = None,
         grain: Grain | None = None,
+        pseudonym_map: dict[str, set[str]] | None = None,
     ):
         self.grain = grain or Grain()
         self.environment = environment
         self.local_concepts: dict[str, BuildConcept] = (
             {} if local_concepts is None else local_concepts
         )
-        self.pseudonym_map = get_canonical_pseudonyms(environment)
+        self.local_non_build_concepts: dict[str, Concept] = {}
+        self.pseudonym_map = pseudonym_map or get_canonical_pseudonyms(environment)
 
     def instantiate_concept(
         self,
@@ -1531,14 +1550,19 @@ class Factory:
             | date
         ),
     ) -> tuple[Concept, BuildConcept]:
-        from trilogy.parsing.common import arbitrary_to_concept
+        from trilogy.parsing.common import arbitrary_to_concept, generate_concept_name
 
+        name = generate_concept_name(arg)
+        if name in self.local_concepts and name in self.local_non_build_concepts:
+            # if we already have this concept, return it
+            return self.local_non_build_concepts[name], self.local_concepts[name]
         new = arbitrary_to_concept(
             arg,
             environment=self.environment,
         )
-        built = self.build(new)
-        self.local_concepts[new.address] = built
+        built = self._build_concept(new)
+        self.local_concepts[name] = built
+        self.local_non_build_concepts[name] = new
         return new, built
 
     @singledispatchmethod
@@ -1576,15 +1600,23 @@ class Factory:
         | DatePart
         | NumericType
     ):
+        return self._build_primitive(base)
+
+    def _build_primitive(self, base):
         return base
 
     @build.register
     def _(self, base: None) -> None:
+        return self._build_none(base)
+
+    def _build_none(self, base):
         return base
 
     @build.register
     def _(self, base: Function) -> BuildFunction | BuildAggregateWrapper:
+        return self._build_function(base)
 
+    def _build_function(self, base: Function) -> BuildFunction | BuildAggregateWrapper:
         raw_args: list[Concept | FuncArgs] = []
         for arg in base.arguments:
             # to do proper discovery, we need to inject virtual intermediate concepts
@@ -1621,22 +1653,22 @@ class Factory:
                     )
                 )
 
-                return BuildFunction.model_construct(
+                return BuildFunction(
                     operator=base.operator,
                     arguments=[
                         rval,
                         *[self.handle_constant(self.build(c)) for c in raw_args[1:]],
                     ],
-                    output_datatype=base.output_datatype,
+                    output_data_type=base.output_datatype,
                     output_purpose=base.output_purpose,
                     valid_inputs=base.valid_inputs,
                     arg_count=base.arg_count,
                 )
 
-        new = BuildFunction.model_construct(
+        new = BuildFunction(
             operator=base.operator,
             arguments=[self.handle_constant(self.build(c)) for c in raw_args],
-            output_datatype=base.output_datatype,
+            output_data_type=base.output_datatype,
             output_purpose=base.output_purpose,
             valid_inputs=base.valid_inputs,
             arg_count=base.arg_count,
@@ -1645,40 +1677,50 @@ class Factory:
 
     @build.register
     def _(self, base: ConceptRef) -> BuildConcept:
+        return self._build_concept_ref(base)
+
+    def _build_concept_ref(self, base: ConceptRef) -> BuildConcept:
         if base.address in self.local_concepts:
             full = self.local_concepts[base.address]
             if isinstance(full, BuildConcept):
                 return full
         if base.address in self.environment.concepts:
             raw = self.environment.concepts[base.address]
-            return self.build(raw)
+            return self._build_concept(raw)
         # this will error by design - TODO - more helpful message?
-        return self.build(self.environment.concepts[base.address])
+        return self._build_concept(self.environment.concepts[base.address])
 
     @build.register
     def _(self, base: CaseWhen) -> BuildCaseWhen:
+        return self._build_case_when(base)
 
+    def _build_case_when(self, base: CaseWhen) -> BuildCaseWhen:
         comparison = base.comparison
         expr: Concept | FuncArgs = base.expr
         validation = requires_concept_nesting(expr)
         if validation:
             expr, _ = self.instantiate_concept(validation)
-        return BuildCaseWhen.model_construct(
+        return BuildCaseWhen(
             comparison=self.build(comparison),
             expr=self.build(expr),
         )
 
     @build.register
     def _(self, base: CaseElse) -> BuildCaseElse:
+        return self._build_case_else(base)
+
+    def _build_case_else(self, base: CaseElse) -> BuildCaseElse:
         expr: Concept | FuncArgs = base.expr
         validation = requires_concept_nesting(expr)
         if validation:
             expr, _ = self.instantiate_concept(validation)
-        return BuildCaseElse.model_construct(expr=self.build(expr))
+        return BuildCaseElse(expr=self.build(expr))
 
     @build.register
     def _(self, base: Concept) -> BuildConcept:
+        return self._build_concept(base)
 
+    def _build_concept(self, base: Concept) -> BuildConcept:
         # TODO: if we are using parameters, wrap it in a new model and use that in rendering
         if base.address in self.local_concepts:
             return self.local_concepts[base.address]
@@ -1707,13 +1749,13 @@ class Factory:
                 for x in self.pseudonym_map.get(base.address, set())
                 if x != base.address
             }
-        rval = BuildConcept.model_construct(
+        rval = BuildConcept(
             name=base.name,
             datatype=base.datatype,
             purpose=base.purpose,
             metadata=base.metadata,
             lineage=build_lineage,
-            grain=self.build(final_grain),
+            grain=self._build_grain(final_grain),
             namespace=base.namespace,
             keys=base.keys,
             modifiers=base.modifiers,
@@ -1723,34 +1765,44 @@ class Factory:
             granularity=granularity,
             build_is_aggregate=is_aggregate,
         )
+        self.local_concepts[base.address] = rval
         return rval
 
     @build.register
     def _(self, base: AggregateWrapper) -> BuildAggregateWrapper:
+        return self._build_aggregate_wrapper(base)
+
+    def _build_aggregate_wrapper(self, base: AggregateWrapper) -> BuildAggregateWrapper:
         if not base.by:
             by = [
-                self.build(self.environment.concepts[c]) for c in self.grain.components
+                self._build_concept(self.environment.concepts[c])
+                for c in self.grain.components
             ]
         else:
             by = [self.build(x) for x in base.by]
 
-        parent = self.build(base.function)
-        return BuildAggregateWrapper.model_construct(function=parent, by=by)
+        parent: BuildFunction = self._build_function(base.function)  # type: ignore
+        return BuildAggregateWrapper(function=parent, by=by)
 
     @build.register
     def _(self, base: ColumnAssignment) -> BuildColumnAssignment:
+        return self._build_column_assignment(base)
+
+    def _build_column_assignment(self, base: ColumnAssignment) -> BuildColumnAssignment:
         address = base.concept.address
         fetched = (
-            self.build(
+            self._build_concept(
                 self.environment.alias_origin_lookup[address].with_grain(self.grain)
             )
             if address in self.environment.alias_origin_lookup
-            else self.build(self.environment.concepts[address].with_grain(self.grain))
+            else self._build_concept(
+                self.environment.concepts[address].with_grain(self.grain)
+            )
         )
 
-        return BuildColumnAssignment.model_construct(
+        return BuildColumnAssignment(
             alias=(
-                self.build(base.alias)
+                self._build_function(base.alias)
                 if isinstance(base.alias, Function)
                 else base.alias
             ),
@@ -1760,44 +1812,55 @@ class Factory:
 
     @build.register
     def _(self, base: OrderBy) -> BuildOrderBy:
-        return BuildOrderBy.model_construct(items=[self.build(x) for x in base.items])
+        return self._build_order_by(base)
+
+    def _build_order_by(self, base: OrderBy) -> BuildOrderBy:
+        return BuildOrderBy(items=[self._build_order_item(x) for x in base.items])
 
     @build.register
     def _(self, base: FunctionCallWrapper) -> BuildExpr:
+        return self._build_function_call_wrapper(base)
+
+    def _build_function_call_wrapper(self, base: FunctionCallWrapper) -> BuildExpr:
         # function calls are kept around purely for the parse tree
         # so discard at the build point
         return self.build(base.content)
 
     @build.register
     def _(self, base: OrderItem) -> BuildOrderItem:
+        return self._build_order_item(base)
 
+    def _build_order_item(self, base: OrderItem) -> BuildOrderItem:
         bexpr: Any
         validation = requires_concept_nesting(base.expr)
         if validation:
             bexpr, _ = self.instantiate_concept(validation)
         else:
             bexpr = base.expr
-        return BuildOrderItem.model_construct(
+        return BuildOrderItem(
             expr=(self.build(bexpr)),
             order=base.order,
         )
 
     @build.register
     def _(self, base: WhereClause) -> BuildWhereClause:
+        return self._build_where_clause(base)
 
-        return BuildWhereClause.model_construct(
-            conditional=self.build(base.conditional)
-        )
+    def _build_where_clause(self, base: WhereClause) -> BuildWhereClause:
+        return BuildWhereClause(conditional=self.build(base.conditional))
 
     @build.register
     def _(self, base: HavingClause) -> BuildHavingClause:
-        return BuildHavingClause.model_construct(
-            conditional=self.build(base.conditional)
-        )
+        return self._build_having_clause(base)
+
+    def _build_having_clause(self, base: HavingClause) -> BuildHavingClause:
+        return BuildHavingClause(conditional=self.build(base.conditional))
 
     @build.register
     def _(self, base: WindowItem) -> BuildWindowItem:
+        return self._build_window_item(base)
 
+    def _build_window_item(self, base: WindowItem) -> BuildWindowItem:
         content: Concept | FuncArgs = base.content
         validation = requires_concept_nesting(base.content)
         if validation:
@@ -1811,17 +1874,20 @@ class Factory:
             ):
                 x.expr.by = [content]
             final_by.append(x)
-        return BuildWindowItem.model_construct(
+        return BuildWindowItem(
             type=base.type,
             content=self.build(content),
             order_by=[self.build(x) for x in final_by],
-            over=[self.build(x) for x in base.over],
+            over=[self._build_concept_ref(x) for x in base.over],
             index=base.index,
         )
 
     @build.register
     def _(self, base: Conditional) -> BuildConditional:
-        return BuildConditional.model_construct(
+        return self._build_conditional(base)
+
+    def _build_conditional(self, base: Conditional) -> BuildConditional:
+        return BuildConditional(
             left=self.handle_constant(self.build(base.left)),
             right=self.handle_constant(self.build(base.right)),
             operator=base.operator,
@@ -1829,12 +1895,17 @@ class Factory:
 
     @build.register
     def _(self, base: SubselectComparison) -> BuildSubselectComparison:
+        return self._build_subselect_comparison(base)
+
+    def _build_subselect_comparison(
+        self, base: SubselectComparison
+    ) -> BuildSubselectComparison:
         right: Any = base.right
         # this has specialized logic - include all Functions
         if isinstance(base.right, (AggregateWrapper, WindowItem, FilterItem, Function)):
             right_c, _ = self.instantiate_concept(base.right)
             right = right_c
-        return BuildSubselectComparison.model_construct(
+        return BuildSubselectComparison(
             left=self.handle_constant(self.build(base.left)),
             right=self.handle_constant(self.build(right)),
             operator=base.operator,
@@ -1842,7 +1913,9 @@ class Factory:
 
     @build.register
     def _(self, base: Comparison) -> BuildComparison:
+        return self._build_comparison(base)
 
+    def _build_comparison(self, base: Comparison) -> BuildComparison:
         left = base.left
         validation = requires_concept_nesting(base.left)
         if validation:
@@ -1853,7 +1926,7 @@ class Factory:
         if validation:
             right_c, _ = self.instantiate_concept(validation)
             right = right_c  # type: ignore
-        return BuildComparison.model_construct(
+        return BuildComparison(
             left=self.handle_constant(self.build(left)),
             right=self.handle_constant(self.build(right)),
             operator=base.operator,
@@ -1861,32 +1934,43 @@ class Factory:
 
     @build.register
     def _(self, base: AlignItem) -> BuildAlignItem:
-        return BuildAlignItem.model_construct(
+        return self._build_align_item(base)
+
+    def _build_align_item(self, base: AlignItem) -> BuildAlignItem:
+        return BuildAlignItem(
             alias=base.alias,
-            concepts=[self.build(x) for x in base.concepts],
+            concepts=[self._build_concept_ref(x) for x in base.concepts],
             namespace=base.namespace,
         )
 
     @build.register
     def _(self, base: AlignClause) -> BuildAlignClause:
-        return BuildAlignClause.model_construct(
-            items=[self.build(x) for x in base.items]
-        )
+        return self._build_align_clause(base)
+
+    def _build_align_clause(self, base: AlignClause) -> BuildAlignClause:
+        return BuildAlignClause(items=[self._build_align_item(x) for x in base.items])
 
     @build.register
     def _(self, base: RowsetItem) -> BuildRowsetItem:
+        return self._build_rowset_item(base)
 
+    def _build_rowset_item(self, base: RowsetItem) -> BuildRowsetItem:
         factory = Factory(
             environment=self.environment,
             local_concepts={},
             grain=base.rowset.select.grain,
+            pseudonym_map=self.pseudonym_map,
         )
         return BuildRowsetItem(
-            content=factory.build(base.content), rowset=factory.build(base.rowset)
+            content=factory._build_concept_ref(base.content),
+            rowset=factory._build_rowset_lineage(base.rowset),
         )
 
     @build.register
     def _(self, base: RowsetLineage) -> BuildRowsetLineage:
+        return self._build_rowset_lineage(base)
+
+    def _build_rowset_lineage(self, base: RowsetLineage) -> BuildRowsetLineage:
         out = BuildRowsetLineage(
             name=base.name,
             derived_concepts=[x.address for x in base.derived_concepts],
@@ -1896,39 +1980,51 @@ class Factory:
 
     @build.register
     def _(self, base: Grain) -> BuildGrain:
+        return self._build_grain(base)
+
+    def _build_grain(self, base: Grain) -> BuildGrain:
         if base.where_clause:
-            factory = Factory(environment=self.environment)
-            where = factory.build(base.where_clause)
+            factory = Factory(
+                environment=self.environment, pseudonym_map=self.pseudonym_map
+            )
+            where = factory._build_where_clause(base.where_clause)
         else:
             where = None
-        return BuildGrain.model_construct(
-            components=base.components, where_clause=where
-        )
+        return BuildGrain(components=base.components, where_clause=where)
 
     @build.register
     def _(self, base: TupleWrapper) -> TupleWrapper:
+        return self._build_tuple_wrapper(base)
+
+    def _build_tuple_wrapper(self, base: TupleWrapper) -> TupleWrapper:
         return TupleWrapper(val=[self.build(x) for x in base.val], type=base.type)
 
     @build.register
     def _(self, base: FilterItem) -> BuildFilterItem:
+        return self._build_filter_item(base)
+
+    def _build_filter_item(self, base: FilterItem) -> BuildFilterItem:
         if isinstance(
             base.content, (Function, AggregateWrapper, WindowItem, FilterItem)
         ):
             _, built = self.instantiate_concept(base.content)
-            return BuildFilterItem.model_construct(
-                content=built, where=self.build(base.where)
-            )
-        return BuildFilterItem.model_construct(
+            return BuildFilterItem(content=built, where=self.build(base.where))
+        return BuildFilterItem(
             content=self.build(base.content), where=self.build(base.where)
         )
 
     @build.register
     def _(self, base: Parenthetical) -> BuildParenthetical:
-        return BuildParenthetical.model_construct(content=(self.build(base.content)))
+        return self._build_parenthetical(base)
+
+    def _build_parenthetical(self, base: Parenthetical) -> BuildParenthetical:
+        return BuildParenthetical(content=(self.build(base.content)))
 
     @build.register
     def _(self, base: SelectLineage) -> BuildSelectLineage:
+        return self._build_select_lineage(base)
 
+    def _build_select_lineage(self, base: SelectLineage) -> BuildSelectLineage:
         from trilogy.core.models.build import (
             BuildSelectLineage,
             Factory,
@@ -1936,12 +2032,18 @@ class Factory:
 
         materialized: dict[str, BuildConcept] = {}
         factory = Factory(
-            grain=base.grain, environment=self.environment, local_concepts=materialized
+            grain=base.grain,
+            environment=self.environment,
+            local_concepts=materialized,
+            pseudonym_map=self.pseudonym_map,
         )
         for k, v in base.local_concepts.items():
             materialized[k] = factory.build(v)
         where_factory = Factory(
-            grain=Grain(), environment=self.environment, local_concepts={}
+            grain=Grain(),
+            environment=self.environment,
+            local_concepts={},
+            pseudonym_map=self.pseudonym_map,
         )
         where_clause = (
             where_factory.build(base.where_clause) if base.where_clause else None
@@ -1985,7 +2087,11 @@ class Factory:
 
     @build.register
     def _(self, base: MultiSelectLineage) -> BuildMultiSelectLineage:
+        return self._build_multi_select_lineage(base)
 
+    def _build_multi_select_lineage(
+        self, base: MultiSelectLineage
+    ) -> BuildMultiSelectLineage:
         local_build_cache: dict[str, BuildConcept] = {}
 
         parents: list[BuildSelectLineage] = [self.build(x) for x in base.selects]
@@ -2000,7 +2106,7 @@ class Factory:
         derived_base = []
         for k in base.derived_concepts:
             base_concept = self.environment.concepts[k]
-            x = BuildConcept.model_construct(
+            x = BuildConcept(
                 name=base_concept.name,
                 datatype=base_concept.datatype,
                 purpose=base_concept.purpose,
@@ -2023,9 +2129,12 @@ class Factory:
             grain=base.grain,
             environment=self.environment,
             local_concepts=local_build_cache,
+            pseudonym_map=self.pseudonym_map,
         )
-        where_factory = Factory(environment=self.environment)
-        lineage = BuildMultiSelectLineage.model_construct(
+        where_factory = Factory(
+            environment=self.environment, pseudonym_map=self.pseudonym_map
+        )
+        lineage = BuildMultiSelectLineage(
             # we don't build selects here; they'll be built automatically in query discovery
             selects=base.selects,
             grain=final_grain,
@@ -2053,6 +2162,9 @@ class Factory:
 
     @build.register
     def _(self, base: Environment):
+        return self._build_environment(base)
+
+    def _build_environment(self, base: Environment):
         from trilogy.core.models.build_environment import BuildEnvironment
 
         new = BuildEnvironment(
@@ -2061,14 +2173,14 @@ class Factory:
         )
 
         for k, v in base.concepts.items():
-            new.concepts[k] = self.build(v)
+            new.concepts[k] = self._build_concept(v)
         for (
             k,
             d,
         ) in base.datasources.items():
-            new.datasources[k] = self.build(d)
+            new.datasources[k] = self._build_datasource(d)
         for k, a in base.alias_origin_lookup.items():
-            new.alias_origin_lookup[k] = self.build(a)
+            new.alias_origin_lookup[k] = self._build_concept(a)
         # add in anything that was built as a side-effect
         for bk, bv in self.local_concepts.items():
             if bk not in new.concepts:
@@ -2078,39 +2190,63 @@ class Factory:
 
     @build.register
     def _(self, base: TraitDataType):
+        return self._build_trait_data_type(base)
+
+    def _build_trait_data_type(self, base: TraitDataType):
         return base
 
     @build.register
     def _(self, base: ArrayType):
+        return self._build_array_type(base)
+
+    def _build_array_type(self, base: ArrayType):
         return base
 
     @build.register
     def _(self, base: StructType):
+        return self._build_struct_type(base)
+
+    def _build_struct_type(self, base: StructType):
         return base
 
     @build.register
     def _(self, base: MapType):
+        return self._build_map_type(base)
+
+    def _build_map_type(self, base: MapType):
         return base
 
     @build.register
     def _(self, base: ArgBinding):
+        return self._build_arg_binding(base)
+
+    def _build_arg_binding(self, base: ArgBinding):
         return base
 
     @build.register
     def _(self, base: Ordering):
+        return self._build_ordering(base)
+
+    def _build_ordering(self, base: Ordering):
         return base
 
     @build.register
     def _(self, base: Datasource):
+        return self._build_datasource(base)
+
+    def _build_datasource(self, base: Datasource):
         local_cache: dict[str, BuildConcept] = {}
         factory = Factory(
-            grain=base.grain, environment=self.environment, local_concepts=local_cache
+            grain=base.grain,
+            environment=self.environment,
+            local_concepts=local_cache,
+            pseudonym_map=self.pseudonym_map,
         )
-        return BuildDatasource.model_construct(
+        return BuildDatasource(
             name=base.name,
-            columns=[factory.build(c) for c in base.columns],
+            columns=[factory._build_column_assignment(c) for c in base.columns],
             address=base.address,
-            grain=factory.build(base.grain),
+            grain=factory._build_grain(base.grain),
             namespace=base.namespace,
             metadata=base.metadata,
             where=(factory.build(base.where) if base.where else None),