pytrilogy 0.0.3.90__py3-none-any.whl → 0.0.3.92__py3-none-any.whl

{pytrilogy-0.0.3.90.dist-info → pytrilogy-0.0.3.92.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.90
+Version: 0.0.3.92
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -52,12 +52,12 @@ The Trilogy language is an experiment in better SQL for analytics - a streamline
 - Testability
 - Easy to use for humans and LLMs
 
-Trilogy is epsecially targeted at data consumption, providing a rich metadata layer that makes visualizing Trilogy easy and expressive. 
+Trilogy is especially powerful for data consumption, providing a rich metadata layer that makes creating, interperting, and visualizing queries easy and expressive. 
 
 > [!TIP]
 > You can try Trilogy in a [open-source studio](https://trilogydata.dev/trilogy-studio-core/). More details on the language can be found on the [documentation](https://trilogydata.dev/).
 
-Start in the studio to explore Trilogy. For deeper work and integration, `pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
+We recommend starting with the studio to explore Trilogy. For integration, `pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
 
 Installation: `pip install pytrilogy`
 
@@ -104,10 +104,13 @@ Save the following code in a file named `hello.preql`
 
 ```python
 # semantic model is abstract from data
+
+type word string; # types can be used to provide expressive metadata tags that propagate through dataflow
+
 key sentence_id int;
-property sentence_id.word_one string; # comments after a definition 
-property sentence_id.word_two string; # are syntactic sugar for adding
-property sentence_id.word_three string; # a description to it
+property sentence_id.word_one string::word; # comments after a definition 
+property sentence_id.word_two string::word; # are syntactic sugar for adding
+property sentence_id.word_three string::word; # a description to it
 
 # comments in other places are just comments
 

{pytrilogy-0.0.3.90.dist-info → pytrilogy-0.0.3.92.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytrilogy-0.0.3.90.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=xsnAVhMdPDgMBudr3tOEYEMfxl0t6RWAK_231sFSxAU,303
+pytrilogy-0.0.3.92.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=f4OB7VJAEeTW-QiyNBxHqoUJrj_7Dk6fryVxppzYalc,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=eKb_EJvSqjN9tGbdVEViwdtwwh8fZ3-jpOEDqL71y70,1691
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
@@ -12,21 +12,21 @@ trilogy/authoring/__init__.py,sha256=e74k-Jep4DLYPQU_2m0aVsYlw5HKTOucAKtdTbd6f2g
 trilogy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/constants.py,sha256=nizWYDCJQ1bigQMtkNIEMNTcN0NoEAXiIHLzpelxQ24,201
 trilogy/core/enums.py,sha256=RQRkpGHLtcBKAO6jZnmGVtSUnb00Q2rP56ltYGdfTok,8294
-trilogy/core/env_processor.py,sha256=pFsxnluKIusGKx1z7tTnfsd_xZcPy9pZDungkjkyvI0,3170
+trilogy/core/env_processor.py,sha256=pD_YYuDG6CMybmwW9H2w958RloA7lEeVbzKXP6ltz2o,4078
 trilogy/core/environment_helpers.py,sha256=VvPIiFemqaLLpIpLIqprfu63K7muZ1YzNg7UZIUph8w,8267
 trilogy/core/ergonomics.py,sha256=e-7gE29vPLFdg0_A1smQ7eOrUwKl5VYdxRSTddHweRA,1631
 trilogy/core/exceptions.py,sha256=jYEduuMehcMkmCpf-OC_taELPZm7qNfeSNzIWkDYScs,707
 trilogy/core/functions.py,sha256=hnfcNjAD-XQ572vEwuUEAdBf8zKFWYwPeHIpESjUpZs,32928
-trilogy/core/graph_models.py,sha256=BYhJzHKSgnZHVLJs1CfsgrxTPHqKqPNeA64RlozGY0A,3498
+trilogy/core/graph_models.py,sha256=zBzUwhYpnDJG91pWtk9ngw1WiTgHkMawyrqXptcGWGA,3847
 trilogy/core/internal.py,sha256=wFx4e1I0mtx159YFShSXeUBSQ82NINtAbOI-92RX4i8,2151
 trilogy/core/optimization.py,sha256=ojpn-p79lr03SSVQbbw74iPCyoYpDYBmj1dbZ3oXCjI,8860
 trilogy/core/query_processor.py,sha256=5aFgv-2LVM1Uku9cR_tFuTRDwyLnxc95bCMAHeFy2AY,20332
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/models/author.py,sha256=tcsr42hHiQ2PHh2_le9sr5IV5nv3twxUv2EXr5iDGxg,80201
-trilogy/core/models/build.py,sha256=CyrSo4xgU-uDKW3xUVYs5cTk3Z3Z2BMWdGQNHnHZOqU,66127
+trilogy/core/models/author.py,sha256=iNnj2exehqj8gzoIwlfpTxhZpS-WqVJwc8OZbiDx1f4,81537
+trilogy/core/models/build.py,sha256=vPMVF7yv_1-sVVpUMupMfWt4BNXFYNSB-WjAL7Eo6lk,71968
 trilogy/core/models/build_environment.py,sha256=s_C9xAHuD3yZ26T15pWVBvoqvlp2LdZ8yjsv2_HdXLk,5363
-trilogy/core/models/core.py,sha256=NOvonI4Ip4thpz5WoJZWbbBa44PFfpd2hXGx2Cbi4CE,12521
+trilogy/core/models/core.py,sha256=nnz3ZROlVT18uygEWqqbfbHmcJkm2UC3VVCrsri_-K0,12836
 trilogy/core/models/datasource.py,sha256=wogTevZ-9CyUW2a8gjzqMCieircxi-J5lkI7EOAZnck,9596
 trilogy/core/models/environment.py,sha256=0IHSCFf5e5b4LPQN3vmjumtfM1iD1tN4WMoUr0UqxZI,27855
 trilogy/core/models/execute.py,sha256=sVWhjwWull-T6pUJizhrYVGCWHY3eZivVN6KNlhcHig,41839
@@ -50,7 +50,7 @@ trilogy/core/processing/node_generators/filter_node.py,sha256=ArBsQJl-4fWBJWCE28
 trilogy/core/processing/node_generators/group_node.py,sha256=1QJhRxsTklJ5xq8wHlAURZaN9gL9FPpeCa1OJ7IwXnY,6769
 trilogy/core/processing/node_generators/group_to_node.py,sha256=jKcNCDOY6fNblrdZwaRU0sbUSr9H0moQbAxrGgX6iGA,3832
 trilogy/core/processing/node_generators/multiselect_node.py,sha256=GWV5yLmKTe1yyPhN60RG1Rnrn4ktfn9lYYXi_FVU4UI,7061
-trilogy/core/processing/node_generators/node_merge_node.py,sha256=sUKS9bSTeYNCyF9jibrkac1_QkmxD-k4x35nQK1b9cM,18312
+trilogy/core/processing/node_generators/node_merge_node.py,sha256=rb6ltJyhAUFairG6LZJ111Zm2uQhXWsSZfSERahUNGc,18258
 trilogy/core/processing/node_generators/recursive_node.py,sha256=l5zdh0dURKwmAy8kK4OpMtZfyUEQRk6N-PwSWIyBpSM,2468
 trilogy/core/processing/node_generators/rowset_node.py,sha256=5L5u6xz1In8EaHQdcYgR2si-tz9WB9YLXURo4AkUT9A,6630
 trilogy/core/processing/node_generators/select_merge_node.py,sha256=Cv2GwNiYSmwewjuK8T3JB3pbgrLZFPsB75DCP153BMA,22818
@@ -94,13 +94,13 @@ trilogy/hooks/graph_hook.py,sha256=5BfR7Dt0bgEsCLgwjowgCsVkboGYfVJGOz8g9mqpnos,4
 trilogy/hooks/query_debugger.py,sha256=1npRjww94sPV5RRBBlLqMJRaFkH9vhEY6o828MeoEcw,5583
 trilogy/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/parsing/common.py,sha256=yV1AckK0h8u1OFeGQBTMu-wuW5m63c5CcZuPicsTH_w,30660
+trilogy/parsing/common.py,sha256=550-L0444GUuBFdiDWkOg_DxnMXtcJFUMES2R5zlwik,31026
 trilogy/parsing/config.py,sha256=Z-DaefdKhPDmSXLgg5V4pebhSB0h590vI0_VtHnlukI,111
 trilogy/parsing/exceptions.py,sha256=Xwwsv2C9kSNv2q-HrrKC1f60JNHShXcCMzstTSEbiCw,154
 trilogy/parsing/helpers.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-trilogy/parsing/parse_engine.py,sha256=fgqCtV6sf9HrkViEjf6XXdRpPf4hJ1gSyzLXZ9sLBHs,80148
+trilogy/parsing/parse_engine.py,sha256=minAI04kKs5uZqRumafMCvC9lRwlcXCLmDigcNOF_7w,80639
 trilogy/parsing/render.py,sha256=HSNntD82GiiwHT-TWPLXAaIMWLYVV5B5zQEsgwrHIBE,19605
-trilogy/parsing/trilogy.lark,sha256=ySzMMLxyPjn74MjFHZxXPTW-jHW68KLPJpiszPvZaO0,15780
+trilogy/parsing/trilogy.lark,sha256=e2YVSxqzRov08AydtDSA8aqSJU2M1eJaidMEkHCdsYE,15896
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=1L0XrH4mVHRt1C9T1HnaDv2_kYEfbWTb5_-cBBke79w,3774
 trilogy/std/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,8 +111,8 @@ trilogy/std/money.preql,sha256=XWwvAV3WxBsHX9zfptoYRnBigcfYwrYtBHXTME0xJuQ,2082
 trilogy/std/net.preql,sha256=WZCuvH87_rZntZiuGJMmBDMVKkdhTtxeHOkrXNwJ1EE,416
 trilogy/std/ranking.preql,sha256=LDoZrYyz4g3xsII9XwXfmstZD-_92i1Eox1UqkBIfi8,83
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.90.dist-info/METADATA,sha256=X046-UiVgiZTCb6DQXtQuzAe9Qm4DNTefqbNXixNx5g,9589
-pytrilogy-0.0.3.90.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrilogy-0.0.3.90.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.90.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.90.dist-info/RECORD,,
+pytrilogy-0.0.3.92.dist-info/METADATA,sha256=6MSVrJ4ZFyG-BbBG4-pDrhVYne9GLVR0sc8Olis00_g,9746
+pytrilogy-0.0.3.92.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrilogy-0.0.3.92.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.92.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.92.dist-info/RECORD,,

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.90"
+__version__ = "0.0.3.92"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/env_processor.py

@@ -8,26 +8,34 @@ from trilogy.core.models.build_environment import BuildEnvironment
 
 
 def add_concept(
-    concept: BuildConcept, g: ReferenceGraph, concept_mapping: dict[str, BuildConcept]
+    concept: BuildConcept,
+    g: ReferenceGraph,
+    concept_mapping: dict[str, BuildConcept],
+    default_concept_graph: dict[str, BuildConcept],
+    seen: set[str],
 ):
-    g.add_node(concept)
+
     # if we have sources, recursively add them
     node_name = concept_to_node(concept)
+    if node_name in seen:
+        return
+    seen.add(node_name)
+    g.add_node(concept)
     if concept.concept_arguments:
         for source in concept.concept_arguments:
             if not isinstance(source, BuildConcept):
                 raise ValueError(
                     f"Invalid non-build concept {source} passed into graph generation from {concept}"
                 )
-            generic = source.with_default_grain()
-            add_concept(generic, g, concept_mapping)
+            generic = get_default_grain_concept(source, default_concept_graph)
+            add_concept(generic, g, concept_mapping, default_concept_graph, seen)
 
             g.add_edge(generic, node_name)
     for ps_address in concept.pseudonyms:
         if ps_address not in concept_mapping:
             raise SyntaxError(f"Concept {concept} has invalid pseudonym {ps_address}")
         pseudonym = concept_mapping[ps_address]
-        pseudonym = pseudonym.with_default_grain()
+        pseudonym = get_default_grain_concept(pseudonym, default_concept_graph)
         pseudonym_node = concept_to_node(pseudonym)
         if (pseudonym_node, node_name) in g.edges and (
             node_name,
@@ -38,16 +46,29 @@ def add_concept(
             continue
         g.add_edge(pseudonym_node, node_name, pseudonym=True)
         g.add_edge(node_name, pseudonym_node, pseudonym=True)
-        add_concept(pseudonym, g, concept_mapping)
+        add_concept(pseudonym, g, concept_mapping, default_concept_graph, seen)
+
+
+def get_default_grain_concept(
+    concept: BuildConcept, default_concept_graph: dict[str, BuildConcept]
+) -> BuildConcept:
+    """Get the default grain concept from the graph."""
+    if concept.address in default_concept_graph:
+        return default_concept_graph[concept.address]
+    default = concept.with_default_grain()
+    default_concept_graph[concept.address] = default
+    return default
 
 
 def generate_adhoc_graph(
     concepts: list[BuildConcept],
     datasources: list[BuildDatasource],
+    default_concept_graph: dict[str, BuildConcept],
     restrict_to_listed: bool = False,
 ) -> ReferenceGraph:
     g = ReferenceGraph()
     concept_mapping = {x.address: x for x in concepts}
+    seen: set[str] = set()
     for concept in concepts:
         if not isinstance(concept, BuildConcept):
             raise ValueError(f"Invalid non-build concept {concept}")
@@ -55,7 +76,7 @@ def generate_adhoc_graph(
     # add all parsed concepts
     for concept in concepts:
 
-        add_concept(concept, g, concept_mapping)
+        add_concept(concept, g, concept_mapping, default_concept_graph, seen)
 
     for dataset in datasources:
         node = datasource_to_node(dataset)
@@ -69,7 +90,7 @@ def generate_adhoc_graph(
             # if there is a key on a table at a different grain
             # add an FK edge to the canonical source, if it exists
             # for example, order ID on order product table
-            default = concept.with_default_grain()
+            default = get_default_grain_concept(concept, default_concept_graph)
             if concept != default:
                 g.add_edge(concept, default)
                 g.add_edge(default, concept)
@@ -79,9 +100,10 @@ def generate_adhoc_graph(
 def generate_graph(
     environment: BuildEnvironment,
 ) -> ReferenceGraph:
-
+    default_concept_graph: dict[str, BuildConcept] = {}
     return generate_adhoc_graph(
         list(environment.concepts.values())
         + list(environment.alias_origin_lookup.values()),
         list(environment.datasources.values()),
+        default_concept_graph=default_concept_graph,
     )

trilogy/core/graph_models.py

@@ -54,7 +54,7 @@ def prune_sources_for_conditions(
 def concept_to_node(input: BuildConcept) -> str:
     # if input.purpose == Purpose.METRIC:
     #     return f"c~{input.namespace}.{input.name}@{input.grain}"
-    return f"c~{input.address}@{input.grain.without_condition()}"
+    return f"c~{input.address}@{input.grain.str_no_condition}"
 
 
 def datasource_to_node(input: BuildDatasource) -> str:
@@ -72,11 +72,15 @@ class ReferenceGraph(nx.DiGraph):
     def add_node(self, node_for_adding, **attr):
         if isinstance(node_for_adding, BuildConcept):
             node_name = concept_to_node(node_for_adding)
+            # if node_name in self.nodes:
+            #     return
             attr["type"] = "concept"
             attr["concept"] = node_for_adding
             attr["grain"] = node_for_adding.grain
         elif isinstance(node_for_adding, BuildDatasource):
             node_name = datasource_to_node(node_for_adding)
+            # if node_name in self.nodes:
+            #     return
             attr["type"] = "datasource"
             attr["ds"] = node_for_adding
             attr["grain"] = node_for_adding.grain
@@ -91,7 +95,10 @@ class ReferenceGraph(nx.DiGraph):
             if u_of_edge not in self.nodes:
                 self.add_node(orig)
         elif isinstance(u_of_edge, BuildDatasource):
+            orig = u_of_edge
             u_of_edge = datasource_to_node(u_of_edge)
+            if u_of_edge not in self.nodes:
+                self.add_node(orig)
 
         if isinstance(v_of_edge, BuildConcept):
             orig = v_of_edge
@@ -99,5 +106,8 @@ class ReferenceGraph(nx.DiGraph):
             if v_of_edge not in self.nodes:
                 self.add_node(orig)
         elif isinstance(v_of_edge, BuildDatasource):
+            orig = v_of_edge
             v_of_edge = datasource_to_node(v_of_edge)
+            if v_of_edge not in self.nodes:
+                self.add_node(orig)
         super().add_edge(u_of_edge, v_of_edge, **attr)

trilogy/core/models/author.py

@@ -460,6 +460,8 @@ class HavingClause(WhereClause):
 class Grain(Namespaced, BaseModel):
     components: set[str] = Field(default_factory=set)
     where_clause: Optional["WhereClause"] = None
+    _str: str | None = None
+    _abstract: bool = False
 
     def without_condition(self):
         return Grain(components=self.components)
@@ -484,12 +486,9 @@ class Grain(Namespaced, BaseModel):
         from trilogy.parsing.common import concepts_to_grain_concepts
 
         x = Grain.model_construct(
-            components={
-                c.address
-                for c in concepts_to_grain_concepts(
-                    concepts, environment=environment, local_concepts=local_concepts
-                )
-            },
+            components=concepts_to_grain_concepts(
+                concepts, environment=environment, local_concepts=local_concepts
+            ),
             where_clause=where_clause,
         )
 
@@ -550,17 +549,22 @@ class Grain(Namespaced, BaseModel):
             where_clause=self.where_clause,
         )
 
-    @property
-    def abstract(self):
+    def _gen_abstract(self) -> bool:
         return not self.components or all(
             [c.endswith(ALL_ROWS_CONCEPT) for c in self.components]
         )
 
+    @property
+    def abstract(self):
+        if not self._abstract:
+            self._abstract = self._gen_abstract()
+        return self._abstract
+
     def __eq__(self, other: object):
         if isinstance(other, list):
-            if not all([isinstance(c, Concept) for c in other]):
-                return False
-            return self.components == set([c.address for c in other])
+            if all([isinstance(c, Concept) for c in other]):
+                return self.components == set([c.address for c in other])
+            return False
         if not isinstance(other, Grain):
             return False
         if self.components == other.components:
@@ -581,15 +585,20 @@ class Grain(Namespaced, BaseModel):
         intersection = self.components.intersection(other.components)
         return Grain(components=intersection)
 
-    def __str__(self):
+    def _gen_str(self) -> str:
         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 __str__(self):
+        if not self._str:
+            self._str = self._gen_str()
+        return self._str
+
     def __radd__(self, other) -> "Grain":
         if other == 0:
             return self
@@ -1666,7 +1675,6 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     def parse_output_datatype(cls, v, info: ValidationInfo):
         values = info.data
         if values.get("operator") == FunctionType.ATTR_ACCESS:
-            print(v)
             if isinstance(v, StructType):
                 raise SyntaxError
         return v
@@ -2335,11 +2343,16 @@ class AlignItem(Namespaced, BaseModel):
 
 class CustomFunctionFactory:
     def __init__(
-        self, function: Expr, namespace: str, function_arguments: list[ArgBinding]
+        self,
+        function: Expr,
+        namespace: str,
+        function_arguments: list[ArgBinding],
+        name: str,
     ):
         self.namespace = namespace
         self.function = function
         self.function_arguments = function_arguments
+        self.name = name
 
     def with_namespace(self, namespace: str):
         self.namespace = namespace
@@ -2364,7 +2377,27 @@ class CustomFunctionFactory:
             for binding in self.function_arguments[len(creation_arg_list) :]:
                 if binding.default is None:
                     raise ValueError(f"Missing argument {binding.name}")
+
                 creation_arg_list.append(binding.default)
+        for arg_idx, arg in enumerate(self.function_arguments):
+            if not arg.datatype or arg.datatype == DataType.UNKNOWN:
+                continue
+            if arg_idx > len(creation_arg_list):
+                continue
+            comparison = arg_to_datatype(creation_arg_list[arg_idx])
+            if comparison != arg.datatype:
+                raise TypeError(
+                    f"Invalid type passed into custom function @{self.name} in position {arg_idx+1} for argument {arg.name}, expected {arg.datatype}, got {comparison}"
+                )
+            if isinstance(arg.datatype, TraitDataType):
+                if not (
+                    isinstance(comparison, TraitDataType)
+                    and all(x in comparison.traits for x in arg.datatype.traits)
+                ):
+                    raise TypeError(
+                        f"Invalid argument type passed into custom function @{self.name} in position {arg_idx+1} for argument {arg.name}, expected traits {arg.datatype.traits}, got {comparison}"
+                    )
+
         if isinstance(nout, Mergeable):
             for idx, x in enumerate(creation_arg_list):
                 if self.namespace == DEFAULT_NAMESPACE:

trilogy/core/models/build.py

@@ -93,7 +93,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 +148,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,14 +161,13 @@ 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):
@@ -268,8 +266,12 @@ class BuildParamaterizedConceptReference(DataTyped, BaseModel):
 class BuildGrain(BaseModel):
     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):
+        if not self.where_clause:
+            return self
         return BuildGrain.model_construct(components=self.components)
 
     @classmethod
@@ -280,13 +282,10 @@ class BuildGrain(BaseModel):
         where_clause: BuildWhereClause | None = None,
     ) -> "BuildGrain":
 
-        return BuildGrain(
-            components={
-                c.address
-                for c in concepts_to_build_grain_concepts(
-                    concepts, environment=environment
-                )
-            },
+        return BuildGrain.model_construct(
+            components=concepts_to_build_grain_concepts(
+                concepts, environment=environment
+            ),
             where_clause=where_clause,
         )
 
@@ -366,15 +365,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
@@ -1141,13 +1160,13 @@ 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.model_construct(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.model_construct(components=args)
 
 
 class BuildAggregateWrapper(BuildConceptArgs, DataTyped, BaseModel):
@@ -1507,13 +1526,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 +1552,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 +1602,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
@@ -1645,19 +1679,24 @@ 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)
@@ -1670,6 +1709,9 @@ class Factory:
 
     @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:
@@ -1678,7 +1720,9 @@ class Factory:
 
     @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]
@@ -1713,7 +1757,7 @@ class Factory:
             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,10 +1767,14 @@ 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
@@ -1739,18 +1787,23 @@ class Factory:
 
     @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(
             alias=(
-                self.build(base.alias)
+                self._build_function(base.alias)
                 if isinstance(base.alias, Function)
                 else base.alias
             ),
@@ -1760,17 +1813,25 @@ class Factory:
 
     @build.register
     def _(self, base: OrderBy) -> BuildOrderBy:
+        return self._build_order_by(base)
+
+    def _build_order_by(self, base: OrderBy) -> BuildOrderBy:
         return BuildOrderBy.model_construct(items=[self.build(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:
@@ -1784,20 +1845,27 @@ class Factory:
 
     @build.register
     def _(self, base: WhereClause) -> BuildWhereClause:
+        return self._build_where_clause(base)
 
+    def _build_where_clause(self, base: WhereClause) -> BuildWhereClause:
         return BuildWhereClause.model_construct(
             conditional=self.build(base.conditional)
         )
 
     @build.register
     def _(self, base: HavingClause) -> BuildHavingClause:
+        return self._build_having_clause(base)
+
+    def _build_having_clause(self, base: HavingClause) -> BuildHavingClause:
         return BuildHavingClause.model_construct(
             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:
@@ -1821,6 +1889,9 @@ class Factory:
 
     @build.register
     def _(self, base: Conditional) -> BuildConditional:
+        return self._build_conditional(base)
+
+    def _build_conditional(self, base: Conditional) -> BuildConditional:
         return BuildConditional.model_construct(
             left=self.handle_constant(self.build(base.left)),
             right=self.handle_constant(self.build(base.right)),
@@ -1829,6 +1900,11 @@ 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)):
@@ -1842,7 +1918,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:
@@ -1861,6 +1939,9 @@ class Factory:
 
     @build.register
     def _(self, base: AlignItem) -> BuildAlignItem:
+        return self._build_align_item(base)
+
+    def _build_align_item(self, base: AlignItem) -> BuildAlignItem:
         return BuildAlignItem.model_construct(
             alias=base.alias,
             concepts=[self.build(x) for x in base.concepts],
@@ -1869,24 +1950,34 @@ class Factory:
 
     @build.register
     def _(self, base: AlignClause) -> BuildAlignClause:
+        return self._build_align_clause(base)
+
+    def _build_align_clause(self, base: AlignClause) -> BuildAlignClause:
         return BuildAlignClause.model_construct(
             items=[self.build(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,8 +1987,13 @@ 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)
+            factory = Factory(
+                environment=self.environment, pseudonym_map=self.pseudonym_map
+            )
             where = factory.build(base.where_clause)
         else:
             where = None
@@ -1907,10 +2003,16 @@ class Factory:
 
     @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)
         ):
@@ -1924,11 +2026,16 @@ class Factory:
 
     @build.register
     def _(self, base: Parenthetical) -> BuildParenthetical:
+        return self._build_parenthetical(base)
+
+    def _build_parenthetical(self, base: Parenthetical) -> BuildParenthetical:
         return BuildParenthetical.model_construct(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 +2043,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 +2098,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]
@@ -2023,8 +2140,11 @@ class Factory:
             grain=base.grain,
             environment=self.environment,
             local_concepts=local_build_cache,
+            pseudonym_map=self.pseudonym_map,
+        )
+        where_factory = Factory(
+            environment=self.environment, pseudonym_map=self.pseudonym_map
         )
-        where_factory = Factory(environment=self.environment)
         lineage = BuildMultiSelectLineage.model_construct(
             # we don't build selects here; they'll be built automatically in query discovery
             selects=base.selects,
@@ -2053,6 +2173,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 +2184,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 +2201,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(
             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),

trilogy/core/models/core.py

@@ -225,6 +225,18 @@ class StructType(BaseModel):
     fields: Sequence[StructComponent | TYPEDEF_TYPES]
     fields_map: Dict[str, DataTyped | int | float | str | StructComponent]
 
+    def __repr__(self):
+        return "struct<{}>".format(
+            ", ".join(
+                f"{field.name}:{field.type.name}"
+                for field in self.fields
+                if isinstance(field, StructComponent)
+            )
+        )
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
     @field_validator("fields", mode="plain")
     def validate_type(cls, v):
         final = []

trilogy/core/processing/node_generators/node_merge_node.py

@@ -453,6 +453,7 @@ def gen_merge_node(
     else:
         all_search_concepts = all_concepts
     all_search_concepts = sorted(all_search_concepts, key=lambda x: x.address)
+    break_set = set([x.address for x in all_search_concepts])
     for filter_downstream in [True, False]:
         weak_resolve = resolve_weak_components(
             all_search_concepts,
@@ -466,27 +467,28 @@ def gen_merge_node(
             logger.info(
                 f"{padding(depth)}{LOGGER_PREFIX} wasn't able to resolve graph through intermediate concept injection with accept_partial {accept_partial}, filter_downstream {filter_downstream}"
             )
-        else:
-            log_graph = [[y.address for y in x] for x in weak_resolve]
-            logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} Was able to resolve graph through weak component resolution - final graph {log_graph}"
-            )
-            for flat in log_graph:
-                if set(flat) == set([x.address for x in all_search_concepts]):
-                    logger.info(
-                        f"{padding(depth)}{LOGGER_PREFIX} expanded concept resolution was identical to search resolution; breaking to avoid recursion error."
-                    )
-                    return None
-            return subgraphs_to_merge_node(
-                weak_resolve,
-                depth=depth,
-                all_concepts=all_search_concepts,
-                environment=environment,
-                g=g,
-                source_concepts=source_concepts,
-                history=history,
-                conditions=conditions,
-                search_conditions=search_conditions,
-                output_concepts=all_concepts,
-            )
+            continue
+
+        log_graph = [[y.address for y in x] for x in weak_resolve]
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} Was able to resolve graph through weak component resolution - final graph {log_graph}"
+        )
+        for flat in log_graph:
+            if set(flat) == break_set:
+                logger.info(
+                    f"{padding(depth)}{LOGGER_PREFIX} expanded concept resolution was identical to search resolution; breaking to avoid recursion error."
+                )
+                return None
+        return subgraphs_to_merge_node(
+            weak_resolve,
+            depth=depth,
+            all_concepts=all_search_concepts,
+            environment=environment,
+            g=g,
+            source_concepts=source_concepts,
+            history=history,
+            conditions=conditions,
+            search_conditions=search_conditions,
+            output_concepts=all_concepts,
+        )
     return None

trilogy/parsing/common.py

@@ -309,7 +309,7 @@ def concepts_to_grain_concepts(
     concepts: Iterable[Concept | ConceptRef | str],
     environment: Environment | None,
     local_concepts: dict[str, Concept] | None = None,
-) -> list[Concept]:
+) -> set[str]:
     preconcepts: list[Concept] = []
     for c in concepts:
         if isinstance(c, Concept):
@@ -329,7 +329,7 @@ def concepts_to_grain_concepts(
             raise ValueError(
                 f"Unable to resolve input {c} without environment provided to concepts_to_grain call"
             )
-    pconcepts = []
+    pconcepts: list[Concept] = []
     for x in preconcepts:
         if (
             x.lineage
@@ -340,14 +340,16 @@ def concepts_to_grain_concepts(
             pconcepts.append(environment.concepts[x.lineage.arguments[0].address])  # type: ignore
         else:
             pconcepts.append(x)
-    final: List[Concept] = []
+
+    seen = set()
     for sub in pconcepts:
+        if sub.address in seen:
+            continue
         if not concept_is_relevant(sub, pconcepts, environment):  # type: ignore
             continue
-        final.append(sub)
-    final = unique(final, "address")
-    v2 = sorted(final, key=lambda x: x.name)
-    return v2
+        seen.add(sub.address)
+
+    return seen
 
 
 def _get_relevant_parent_concepts(arg) -> tuple[list[ConceptRef], bool]:
@@ -823,6 +825,40 @@ def rowset_to_concepts(rowset: RowsetDerivationStatement, environment: Environme
     return pre_output
 
 
+def generate_concept_name(
+    parent: (
+        AggregateWrapper
+        | FunctionCallWrapper
+        | WindowItem
+        | FilterItem
+        | Function
+        | ListWrapper
+        | MapWrapper
+        | int
+        | float
+        | str
+        | date
+    ),
+) -> str:
+    """Generate a name for a concept based on its parent type and content."""
+    if isinstance(parent, AggregateWrapper):
+        return f"{VIRTUAL_CONCEPT_PREFIX}_agg_{parent.function.operator.value}_{string_to_hash(str(parent))}"
+    elif isinstance(parent, WindowItem):
+        return f"{VIRTUAL_CONCEPT_PREFIX}_window_{parent.type.value}_{string_to_hash(str(parent))}"
+    elif isinstance(parent, FilterItem):
+        if isinstance(parent.content, ConceptRef):
+            return f"{VIRTUAL_CONCEPT_PREFIX}_filter_{parent.content.name}_{string_to_hash(str(parent))}"
+        else:
+            return f"{VIRTUAL_CONCEPT_PREFIX}_filter_{string_to_hash(str(parent))}"
+    elif isinstance(parent, Function):
+        if parent.operator == FunctionType.GROUP:
+            return f"{VIRTUAL_CONCEPT_PREFIX}_group_to_{string_to_hash(str(parent))}"
+        else:
+            return f"{VIRTUAL_CONCEPT_PREFIX}_func_{parent.operator.value}_{string_to_hash(str(parent))}"
+    else:  # ListWrapper, MapWrapper, or primitive types
+        return f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"
+
+
 def arbitrary_to_concept(
     parent: (
         AggregateWrapper
@@ -843,20 +879,22 @@ def arbitrary_to_concept(
     metadata: Metadata | None = None,
 ) -> Concept:
     namespace = namespace or environment.namespace
+
     # this is purely for the parse tree, discard from derivation
     if isinstance(parent, FunctionCallWrapper):
         return arbitrary_to_concept(
             parent.content, environment, namespace, name, metadata  # type: ignore
         )
-    elif isinstance(parent, AggregateWrapper):
-        if not name:
-            name = f"{VIRTUAL_CONCEPT_PREFIX}_agg_{parent.function.operator.value}_{string_to_hash(str(parent))}"
+
+    # Generate name if not provided
+    if not name:
+        name = generate_concept_name(parent)
+
+    if isinstance(parent, AggregateWrapper):
         return agg_wrapper_to_concept(
             parent, namespace, name, metadata=metadata, environment=environment
         )
     elif isinstance(parent, WindowItem):
-        if not name:
-            name = f"{VIRTUAL_CONCEPT_PREFIX}_window_{parent.type.value}_{string_to_hash(str(parent))}"
         return window_item_to_concept(
             parent,
             name,
@@ -865,11 +903,6 @@ def arbitrary_to_concept(
             metadata=metadata,
         )
     elif isinstance(parent, FilterItem):
-        if not name:
-            if isinstance(parent.content, ConceptRef):
-                name = f"{VIRTUAL_CONCEPT_PREFIX}_filter_{parent.content.name}_{string_to_hash(str(parent))}"
-            else:
-                name = f"{VIRTUAL_CONCEPT_PREFIX}_filter_{string_to_hash(str(parent))}"
         return filter_item_to_concept(
             parent,
             name,
@@ -878,14 +911,6 @@ def arbitrary_to_concept(
             metadata=metadata,
         )
     elif isinstance(parent, Function):
-        if not name:
-            if parent.operator == FunctionType.GROUP:
-                name = (
-                    f"{VIRTUAL_CONCEPT_PREFIX}_group_to_{string_to_hash(str(parent))}"
-                )
-            else:
-                name = f"{VIRTUAL_CONCEPT_PREFIX}_func_{parent.operator.value}_{string_to_hash(str(parent))}"
-
         if parent.operator == FunctionType.GROUP:
             return group_function_to_concept(
                 parent,
@@ -902,10 +927,6 @@ def arbitrary_to_concept(
             namespace=namespace,
         )
     elif isinstance(parent, ListWrapper):
-        if not name:
-            name = f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"
         return constant_to_concept(parent, name, namespace, metadata)
     else:
-        if not name:
-            name = f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"
         return constant_to_concept(parent, name, namespace, metadata)

trilogy/parsing/parse_engine.py

@@ -161,6 +161,11 @@ class WholeGrainWrapper:
     where: WhereClause
 
 
+@dataclass
+class FunctionBindingType:
+    type: DataType | TraitDataType | None = None
+
+
 with open(join(dirname(__file__), "trilogy.lark"), "r") as f:
     PARSER = Lark(
         f.read(),
@@ -1373,11 +1378,24 @@ class ParseToObjects(Transformer):
     def function_binding_list(self, meta: Meta, args) -> list[ArgBinding]:
         return args
 
+    @v_args(meta=True)
+    def function_binding_type(self, meta: Meta, args) -> FunctionBindingType:
+        return FunctionBindingType(type=args[0])
+
+    @v_args(meta=True)
+    def function_binding_default(self, meta: Meta, args):
+        return args[1]
+
     @v_args(meta=True)
     def function_binding_item(self, meta: Meta, args) -> ArgBinding:
-        if len(args) == 2:
-            return ArgBinding.model_construct(name=args[0], default=args[1])
-        return ArgBinding.model_construct(name=args[0], default=None)
+        default = None
+        type = None
+        for arg in args[1:]:
+            if isinstance(arg, FunctionBindingType):
+                type = arg.type
+            else:
+                default = arg
+        return ArgBinding.model_construct(name=args[0], datatype=type, default=default)
 
     @v_args(meta=True)
     def raw_function(self, meta: Meta, args) -> FunctionDeclaration:
@@ -1389,6 +1407,7 @@ class ParseToObjects(Transformer):
             function=output,
             namespace=self.environment.namespace,
             function_arguments=function_arguments,
+            name=identity,
         )
         return FunctionDeclaration(name=identity, args=function_arguments, expr=output)
 

trilogy/parsing/trilogy.lark

@@ -91,7 +91,9 @@
 
     // FUNCTION blocks
     function: raw_function
-    function_binding_item: IDENTIFIER ("=" literal)?
+    function_binding_type: ":" data_type  
+    function_binding_default: /=/ expr
+    function_binding_item: IDENTIFIER function_binding_type? function_binding_default?
     function_binding_list: (function_binding_item ",")* function_binding_item ","?
     raw_function: "def"  IDENTIFIER  "("  function_binding_list ")" "->" expr