pytrilogy 0.0.2.55__py3-none-any.whl → 0.0.2.57__py3-none-any.whl

{pytrilogy-0.0.2.55.dist-info → pytrilogy-0.0.2.57.dist-info}/METADATA

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

{pytrilogy-0.0.2.55.dist-info → pytrilogy-0.0.2.57.dist-info}/RECORD

@@ -1,43 +1,43 @@
-trilogy/__init__.py,sha256=JnykGbcn-V3aG4x6q9pNpBv7a-8Pr93-61ey6CjNHBA,291
+trilogy/__init__.py,sha256=YgiCOJgZfH7Ciz9GfXgtxr5_r5NkhAaRoFEru-cSoQs,291
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=qZ1d0hoKPPV2HHCoFwPYTVB7b6bXjpWvXd3lE-zEhy8,1494
 trilogy/engine.py,sha256=yOPnR7XCjWG82Gym_LLZBkYKKJdLCvqdCyt8zguNcnM,1103
 trilogy/executor.py,sha256=SbReI_xWd081WZeRt_YAyVTdMOGg2XPrsaOKgMS7YUY,15969
 trilogy/parser.py,sha256=UtuqSiGiCjpMAYgo1bvNq-b7NSzCA5hzbUW31RXaMII,281
 trilogy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/utility.py,sha256=eguES83XhmSOAQSBu5xq4aAXimiZFrxcUu81zDL22ug,707
+trilogy/utility.py,sha256=euQccZLKoYBz0LNg5tzLlvv2YHvXh9HArnYp1V3uXsM,763
 trilogy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/constants.py,sha256=7XaCpZn5mQmjTobbeBn56SzPWq9eMNDfzfsRU-fP0VE,171
 trilogy/core/enums.py,sha256=6pGjEXNJPB1ngbDQRJjxRi4NmKM8NZQ5-iwnZhrdo5U,7281
 trilogy/core/env_processor.py,sha256=Pt4lmJfbShBbeSe5M7_FrTk5krrOziiAA__Slnettvc,2585
-trilogy/core/environment_helpers.py,sha256=GExsRXghccqKOIiEjkCjtDVDz0PNTE5OSRPFelPa5eU,7279
+trilogy/core/environment_helpers.py,sha256=ugKDnPYQNxKzc1Weq_kj9IVppNdgT8iS1RTS_f5hHxc,7905
 trilogy/core/ergonomics.py,sha256=ASLDd0RqKWrZiG3XcKHo8nyTjaB_8xfE9t4NZ1UvGpc,1639
 trilogy/core/exceptions.py,sha256=1c1lQCwSw4_5CQS3q7scOkXU8GQvullJXfPHubprl90,617
-trilogy/core/functions.py,sha256=hDlwLxQUskT9iRcIic1lfACQnxMLNM5ASdHRPi0ghyw,10835
+trilogy/core/functions.py,sha256=8auZhInqnY28zg7Kil4LbvDT7jD4JggwS6HzK6ZIemE,10867
 trilogy/core/graph_models.py,sha256=mameUTiuCajtihDw_2-W218xyJlvTusOWrEKP1yAWgk,2003
 trilogy/core/internal.py,sha256=FQWbuETKPfzjALMmdXJwlOMlESfm2Z5gmErSsq3BX9c,1173
-trilogy/core/models.py,sha256=J1s7EAbJIoHseoz1D1iP1sAbEDNt66cinS2VE-zLp7g,161242
+trilogy/core/models.py,sha256=FO1JUeUN8N3qqIjytLimayNLQWczq0aAYwephZyq7Ec,165389
 trilogy/core/optimization.py,sha256=Jy3tVJNeqhpK6VSyTvgIWKCao6y-VCZ7mYA69MIF6L0,7989
-trilogy/core/query_processor.py,sha256=V-TqybYO0kCY8O7Nk58OBhb7_eRPs_EqAwaQv-EYLSY,18615
+trilogy/core/query_processor.py,sha256=JUtsDh64mWwQHM3HFZMPtVCu-Yw7WsK3cx4NxiMACSM,18584
 trilogy/core/optimizations/__init__.py,sha256=EBanqTXEzf1ZEYjAneIWoIcxtMDite5-n2dQ5xcfUtg,356
 trilogy/core/optimizations/base_optimization.py,sha256=P4kF-eCXkBxO-5c6tLHhMZ4ODRH1A04hb_6ovkaVyLw,505
 trilogy/core/optimizations/inline_constant.py,sha256=c-YHOg6eAufL4EaCf4-0PbY_D4skBHW0ldR55_phsMA,1277
 trilogy/core/optimizations/inline_datasource.py,sha256=LsngRKBy-LYcx1sfo1-rnDym_ly73YV9WkEngSjpFx8,3943
 trilogy/core/optimizations/predicate_pushdown.py,sha256=XPWEBv8jXnc0OL2JDPNwFvJ5AtOE7dLzJK0LzdmdZMo,9252
 trilogy/core/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/processing/concept_strategies_v3.py,sha256=TrkaE8bY0AU7XiLP47rLqqFqkfiinrNF3v6C6DtZiY4,37474
+trilogy/core/processing/concept_strategies_v3.py,sha256=hgxQ5nrlLYfx02yM--7GN8MoYYX06iLBFujjPoZaxGI,37683
 trilogy/core/processing/graph_utils.py,sha256=stbYnDxnK-1kbo9L4XNU85FQhWCP-oZYO7LCXhAdC5M,1198
-trilogy/core/processing/utility.py,sha256=STqSHP8fWTVmaIUCfHAb9Hke_fzOG2pTbmWIdYS4cvc,18787
+trilogy/core/processing/utility.py,sha256=JpyPScfD8i4CgsTZSR0siWdXVhQDHizBAiQc81d7lbw,19769
 trilogy/core/processing/node_generators/__init__.py,sha256=s_YV1OYc336DuS9591259qjI_K_CtOCuhkf4t2aOgYs,733
-trilogy/core/processing/node_generators/basic_node.py,sha256=dz7i0BSn4qRv6SBIS_JnVAm09-nkNizoAHrznmqnJXY,3074
+trilogy/core/processing/node_generators/basic_node.py,sha256=pExVmLDQK9okXNeC1-jQgDwpj8JWAgQfejd2lMt8L4U,3157
 trilogy/core/processing/node_generators/common.py,sha256=dHycWu9iiRxH3WIkkyibsnYD5mJfXvdEOhsTvyaO8fg,9128
-trilogy/core/processing/node_generators/filter_node.py,sha256=zDgPfj-LkjkLKasH6Obftw-ojxVQi1d984nvxwTLPEU,7634
+trilogy/core/processing/node_generators/filter_node.py,sha256=aWR82yAZOAnUrJejTj6yD4jpqH6cSPzyJMd1V-M0Kj0,7883
 trilogy/core/processing/node_generators/group_node.py,sha256=k57SVWHSVvTqCd47tyLUGCsSZaP7UQqMCJYTSz1S7oQ,5566
-trilogy/core/processing/node_generators/group_to_node.py,sha256=8ToptIWQoJttquEPrRTMvU33jCJQI-VJxVObN8W8QJk,2511
-trilogy/core/processing/node_generators/multiselect_node.py,sha256=se-cHRYRPskxq2Wq9bw5LkUFSCN1rhk8_05-OTezLz0,6421
+trilogy/core/processing/node_generators/group_to_node.py,sha256=Hz17vZ1EjKVa275CZPF12FkLdrc916PA5T6OsfgryRQ,2928
+trilogy/core/processing/node_generators/multiselect_node.py,sha256=9bQPla367WT85iWGZxlZM4EWkWFGM0i6jgBuA4O0QvQ,6464
 trilogy/core/processing/node_generators/node_merge_node.py,sha256=3GzuiTiorFVe9MyLhoz2PDyI0x9XL7bQ8ucEbV54le8,14627
-trilogy/core/processing/node_generators/rowset_node.py,sha256=ekrXWFu4ga3VR59Ux870w5gSmzFPC9WjIRuyB4yFqag,5138
-trilogy/core/processing/node_generators/select_merge_node.py,sha256=YW0H81IpE9B6f0SK75QH2DVSfr8d3oA9AbbqP44Jhnc,15746
+trilogy/core/processing/node_generators/rowset_node.py,sha256=aSk1Ltv1S6aSRKHpWGjEjgrNTbJXuIXkFiGQVZOyb1o,5139
+trilogy/core/processing/node_generators/select_merge_node.py,sha256=yfNeuc24Ejn7j07szwJif60qmU6OVk3wfa7C2_RJ39k,15996
 trilogy/core/processing/node_generators/select_node.py,sha256=bjTylBa-vYbmzpuSpphmIo_Oi78YZpI8ppHnN9KDYDk,1795
 trilogy/core/processing/node_generators/union_node.py,sha256=MfJjF2m0ARl0oUH9QT1awzPv0e3yA3mXK1XqAvUTgKw,2504
 trilogy/core/processing/node_generators/unnest_node.py,sha256=8El2B1mzC9vIUSk-m94xHvaJwAf5GtCAGfTxGDSiqmU,2229
@@ -45,16 +45,16 @@ trilogy/core/processing/node_generators/window_node.py,sha256=5htRRxaxw6EnS-2TVo
 trilogy/core/processing/node_generators/select_helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/processing/node_generators/select_helpers/datasource_injection.py,sha256=hJZS7GT0dl7sK0riweEwVAVRv5LCXOnMD1hF0XY9hpE,6548
 trilogy/core/processing/nodes/__init__.py,sha256=WNUmYmZF3uqF2qiJ1L7y0u9qiVD9YnluKds0wA5opJE,4813
-trilogy/core/processing/nodes/base_node.py,sha256=KFk6sKNS3lEA_JyimHqdry4-QNEntnMO0GBBC_oA1bs,15552
+trilogy/core/processing/nodes/base_node.py,sha256=utIs_c5V7SIRDPrIVlHJ7zD4caRFmffhuJQSM4cVYoY,16104
 trilogy/core/processing/nodes/filter_node.py,sha256=j7icDAXJ7oFPkHTOQVmm9QbZxrhhYEUGJj2lSiguXKA,2292
-trilogy/core/processing/nodes/group_node.py,sha256=C2U4kyfYnM0Gy1b_C5K-uh-s-9Kncr5olFxMuF0G7zQ,7852
-trilogy/core/processing/nodes/merge_node.py,sha256=p9KoJmOoPqXlehYWj5pF_VuP5ZESTr5dAjAOQbf66O8,14875
+trilogy/core/processing/nodes/group_node.py,sha256=-dx_g1b6j3zygLKWp8yPYtnFxwLtKT9wHv62-U7GBZQ,7273
+trilogy/core/processing/nodes/merge_node.py,sha256=kU4JChblGEoule-qKyXAwlQ2UtLXZsvugL50iUVQvQQ,14760
 trilogy/core/processing/nodes/select_node_v2.py,sha256=t3ln9Kxeml8mVTnLgtNPvavb5TLTRtfkJ0nyxh7UYUs,8212
 trilogy/core/processing/nodes/union_node.py,sha256=1QgOWkjJ-ADFdanoRzi0EM5buhuzJbmlda9BAUGp4mM,1352
 trilogy/core/processing/nodes/unnest_node.py,sha256=0TFANwqVPaVpUR6SF5uweGTlXfEnagXRBBZU6dUwtcY,2101
 trilogy/core/processing/nodes/window_node.py,sha256=yYwWuOq1Uwm-xEl8lFH_urm-YXaAGAgNhE20MEoD5QQ,1163
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=DR7cHoL5rbRBnsj6PCq5wK8GHH-l5szpKXUaxMqx1Mw,38568
+trilogy/dialect/base.py,sha256=jRHr_LrI0M7Pak3HizuBcbeTnAJ2e0NoYLMpGHXJhUw,38590
 trilogy/dialect/bigquery.py,sha256=mKC3zoEU232h9RtIXJjqiZ72lWH8a6S28p6wAZKrAfg,2952
 trilogy/dialect/common.py,sha256=b0E6JqdKaaSzThLiFa9jwUg4YnXahf-3bqmzOn5z-6E,3827
 trilogy/dialect/config.py,sha256=UiBY2tBbNk9owx-zxP_3lN9lErEUXhXIU_bcXA18AvU,2992
@@ -74,14 +74,14 @@ trilogy/parsing/common.py,sha256=iPpnSkiKUtoSTsfrMCHZOexu9H6-eIQznbVsKNEPbT8,120
 trilogy/parsing/config.py,sha256=Z-DaefdKhPDmSXLgg5V4pebhSB0h590vI0_VtHnlukI,111
 trilogy/parsing/exceptions.py,sha256=92E5i2frv5hj9wxObJZsZqj5T6bglvPzvdvco_vW1Zk,38
 trilogy/parsing/helpers.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-trilogy/parsing/parse_engine.py,sha256=JGL2qm4L14ytkkB4FiwaXvC1EYJSOK9J0eemi6L94Bw,69222
+trilogy/parsing/parse_engine.py,sha256=rxbCR-gIK5EQsHUYCj1r0n73NiKOAt-vJq21-qXVPks,66131
 trilogy/parsing/render.py,sha256=o4C12a407iZvlRGUJDiuJUezrLLo4QEaLtu60ZQX3gk,16942
 trilogy/parsing/trilogy.lark,sha256=EazfEvYPuvkPkNjUnVzFi0uD9baavugbSI8CyfawShk,12573
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=DQDW81E5mDMWFP8oPw8q-IyrR2JGxQSDWgUWe2VTSRQ,3731
-pytrilogy-0.0.2.55.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-pytrilogy-0.0.2.55.dist-info/METADATA,sha256=FFvNA0mm8yeWHphFZm0-LAIoPu_qbPSSYwTzoXVz1yI,8823
-pytrilogy-0.0.2.55.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pytrilogy-0.0.2.55.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
-pytrilogy-0.0.2.55.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.2.55.dist-info/RECORD,,
+pytrilogy-0.0.2.57.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+pytrilogy-0.0.2.57.dist-info/METADATA,sha256=--PBPmro81sFziRia1QJYSp1zQBGRmEUo46DYa-xBgg,8823
+pytrilogy-0.0.2.57.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pytrilogy-0.0.2.57.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
+pytrilogy-0.0.2.57.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.2.57.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.2.55"
+__version__ = "0.0.2.57"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/environment_helpers.py

@@ -11,12 +11,23 @@ from trilogy.core.models import (
 )
 from trilogy.parsing.common import Meta, arg_to_datatype, process_function_args
 
+FUNCTION_DESCRIPTION_MAPS = {
+    FunctionType.DATE: "The date part of a timestamp/date. Integer, 0-31 depending on month.",
+    FunctionType.MONTH: "The month part of a timestamp/date. Integer, 1-12.",
+    FunctionType.YEAR: "The year part of a timestamp/date. Integer.",
+    FunctionType.QUARTER: "The quarter part of a timestamp/date. Integer, 1-4.",
+    FunctionType.DAY_OF_WEEK: "The day of the week part of a timestamp/date. Integer, 0-6.",
+    FunctionType.HOUR: "The hour part of a timestamp. Integer, 0-23.",
+    FunctionType.MINUTE: "The minute part of a timestamp. Integer, 0-59.",
+    FunctionType.SECOND: "The second part of a timestamp. Integer, 0-59.",
+}
+
 
 def generate_date_concepts(concept: Concept, environment: Environment):
     if concept.metadata and concept.metadata.description:
         base_description = concept.metadata.description
     else:
-        base_description = f"a {concept.datatype.value}"
+        base_description = f"a {concept.address}"
     if concept.metadata and concept.metadata.line_number:
         base_line_number = concept.metadata.line_number
     else:
@@ -54,7 +65,7 @@ def generate_date_concepts(concept: Concept, environment: Environment):
                 concept.address,
             ),
             metadata=Metadata(
-                description=f"Auto-derived. Integer format. The {ftype.value} derived from {concept.name}, {base_description}",
+                description=f"Auto-derived from {base_description}. {FUNCTION_DESCRIPTION_MAPS.get(ftype, ftype.value)}. ",
                 line_number=base_line_number,
                 concept_source=ConceptSource.AUTO_DERIVED,
             ),
@@ -68,7 +79,7 @@ def generate_datetime_concepts(concept: Concept, environment: Environment):
     if concept.metadata and concept.metadata.description:
         base_description = concept.metadata.description
     else:
-        base_description = f"a {concept.datatype.value}"
+        base_description = concept.address
     if concept.metadata and concept.metadata.line_number:
         base_line_number = concept.metadata.line_number
     else:
@@ -105,7 +116,7 @@ def generate_datetime_concepts(concept: Concept, environment: Environment):
                 concept.address,
             ),
             metadata=Metadata(
-                description=f"Auto-derived. Integer format. The {ftype.value} derived from {concept.name}, {base_description}",
+                description=f"Auto-derived from {base_description}. {FUNCTION_DESCRIPTION_MAPS.get(ftype, ftype.value)}.",
                 line_number=base_line_number,
                 concept_source=ConceptSource.AUTO_DERIVED,
             ),
@@ -147,7 +158,7 @@ def generate_key_concepts(concept: Concept, environment: Environment):
                 concept.address,
             },
             metadata=Metadata(
-                description=f"Auto-derived. Integer format. The {ftype.value} derived from {concept.name}, {base_description}",
+                description=f"Auto-derived integer. The {ftype.value} of {concept.address}, {base_description}",
                 line_number=base_line_number,
                 concept_source=ConceptSource.AUTO_DERIVED,
             ),

trilogy/core/functions.py

@@ -127,10 +127,11 @@ def Unnest(args: list[Concept]) -> Function:
 
 def Group(args: list[Concept]) -> Function:
     output = args[0]
+    datatype = arg_to_datatype(output)
     return Function(
         operator=FunctionType.GROUP,
         arguments=args,
-        output_datatype=output.datatype,
+        output_datatype=datatype,
         output_purpose=Purpose.PROPERTY,
         arg_count=-1,
     )

trilogy/core/models.py

@@ -620,7 +620,7 @@ class Concept(Mergeable, Namespaced, SelectContext, BaseModel):
             )
         final_grain = self.grain or grain
         keys = self.keys if self.keys else None
-        if self.is_aggregate and isinstance(new_lineage, Function):
+        if self.is_aggregate and isinstance(new_lineage, Function) and grain.components:
             grain_components = [environment.concepts[c] for c in grain.components]
             new_lineage = AggregateWrapper(function=new_lineage, by=grain_components)
             final_grain = grain
@@ -923,9 +923,16 @@ class Grain(Namespaced, BaseModel):
             if not self.where_clause:
                 where = other.where_clause
             elif not other.where_clause == self.where_clause:
-                raise NotImplementedError(
-                    f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
+                where = WhereClause(
+                    conditional=Conditional(
+                        left=self.where_clause.conditional,
+                        right=other.where_clause.conditional,
+                        operator=BooleanOperator.AND,
+                    )
                 )
+                # raise NotImplementedError(
+                #     f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
+                # )
         return Grain(
             components=self.components.union(other.components), where_clause=where
         )
@@ -1015,6 +1022,7 @@ class EnvironmentConceptDict(dict):
     def raise_undefined(
         self, key: str, line_no: int | None = None, file: Path | str | None = None
     ) -> Never:
+
         matches = self._find_similar_concepts(key)
         message = f"Undefined concept: {key}."
         if matches:
@@ -1660,6 +1668,96 @@ class SelectStatement(HasUUID, Mergeable, Namespaced, SelectTypeMixin, BaseModel
     ] = Field(default_factory=EnvironmentConceptDict)
     grain: Grain = Field(default_factory=Grain)
 
+    @classmethod
+    def from_inputs(
+        cls,
+        environment: Environment,
+        selection: List[SelectItem],
+        order_by: OrderBy | None = None,
+        limit: int | None = None,
+        meta: Metadata | None = None,
+        where_clause: WhereClause | None = None,
+        having_clause: HavingClause | None = None,
+    ) -> "SelectStatement":
+
+        output = SelectStatement(
+            selection=selection,
+            where_clause=where_clause,
+            having_clause=having_clause,
+            limit=limit,
+            order_by=order_by,
+            meta=meta or Metadata(),
+        )
+        for parse_pass in [
+            1,
+            2,
+        ]:
+            # the first pass will result in all concepts being defined
+            # the second will get grains appropriately
+            # eg if someone does sum(x)->a, b+c -> z - we don't know if Z is a key to group by or an aggregate
+            # until after the first pass, and so don't know the grain of a
+
+            if parse_pass == 1:
+                grain = Grain.from_concepts(
+                    [
+                        x.content
+                        for x in output.selection
+                        if isinstance(x.content, Concept)
+                    ],
+                    where_clause=output.where_clause,
+                )
+            if parse_pass == 2:
+                grain = Grain.from_concepts(
+                    output.output_components, where_clause=output.where_clause
+                )
+            output.grain = grain
+            pass_grain = Grain() if parse_pass == 1 else grain
+            for item in selection:
+                # we don't know the grain of an aggregate at assignment time
+                # so rebuild at this point in the tree
+                # TODO: simplify
+                if isinstance(item.content, ConceptTransform):
+                    new_concept = item.content.output.with_select_context(
+                        output.local_concepts,
+                        # the first pass grain will be incorrect
+                        pass_grain,
+                        environment=environment,
+                    )
+                    output.local_concepts[new_concept.address] = new_concept
+                    item.content.output = new_concept
+                    if parse_pass == 2 and CONFIG.select_as_definition:
+                        environment.add_concept(new_concept)
+                elif isinstance(item.content, UndefinedConcept):
+                    environment.concepts.raise_undefined(
+                        item.content.address,
+                        line_no=item.content.metadata.line_number,
+                        file=environment.env_file_path,
+                    )
+                elif isinstance(item.content, Concept):
+                    # Sometimes cached values here don't have the latest info
+                    # but we can't just use environment, as it might not have the right grain.
+                    item.content = item.content.with_select_context(
+                        output.local_concepts,
+                        pass_grain,
+                        environment=environment,
+                    )
+                    output.local_concepts[item.content.address] = item.content
+
+        if order_by:
+            output.order_by = order_by.with_select_context(
+                local_concepts=output.local_concepts,
+                grain=output.grain,
+                environment=environment,
+            )
+        if output.having_clause:
+            output.having_clause = output.having_clause.with_select_context(
+                local_concepts=output.local_concepts,
+                grain=output.grain,
+                environment=environment,
+            )
+        output.validate_syntax(environment)
+        return output
+
     def validate_syntax(self, environment: Environment):
         if self.where_clause:
             for x in self.where_clause.concept_arguments:
@@ -2091,6 +2189,10 @@ class Datasource(HasUUID, Namespaced, BaseModel):
     def duplicate(self) -> Datasource:
         return self.model_copy(deep=True)
 
+    @property
+    def hidden_concepts(self) -> List[Concept]:
+        return []
+
     def merge_concept(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
     ):
@@ -2163,17 +2265,7 @@ class Datasource(HasUUID, Namespaced, BaseModel):
     @field_validator("grain", mode="before")
     @classmethod
     def grain_enforcement(cls, v: Grain, info: ValidationInfo):
-        values = info.data
         grain: Grain = safe_grain(v)
-        if not grain.components:
-            columns: List[ColumnAssignment] = values.get("columns", [])
-            grain = Grain.from_concepts(
-                [
-                    c.concept.with_grain(Grain())
-                    for c in columns
-                    if c.concept.purpose == Purpose.KEY
-                ]
-            )
         return grain
 
     def add_column(
@@ -2982,12 +3074,18 @@ class CTE(BaseModel):
                 assert isinstance(c.lineage, RowsetItem)
                 return check_is_not_in_group(c.lineage.content)
             if c.derivation == PurposeLineage.CONSTANT:
-                return False
+                return True
             if c.purpose == Purpose.METRIC:
                 return True
-            elif c.derivation == PurposeLineage.BASIC and c.lineage:
+
+            if c.derivation == PurposeLineage.BASIC and c.lineage:
                 if all([check_is_not_in_group(x) for x in c.lineage.concept_arguments]):
                     return True
+                if (
+                    isinstance(c.lineage, Function)
+                    and c.lineage.operator == FunctionType.GROUP
+                ):
+                    return check_is_not_in_group(c.lineage.concept_arguments[0])
             return False
 
         return (
@@ -3264,6 +3362,7 @@ class Environment(BaseModel):
     alias_origin_lookup: Dict[str, Concept] = Field(default_factory=dict)
     # TODO: support freezing environments to avoid mutation
     frozen: bool = False
+    env_file_path: Path | None = None
 
     def freeze(self):
         self.frozen = True
@@ -3317,7 +3416,7 @@ class Environment(BaseModel):
             path = Path(path)
         with open(path, "r") as f:
             read = f.read()
-        return Environment(working_path=Path(path).parent).parse(read)[0]
+        return Environment(working_path=path.parent, env_file_path=path).parse(read)[0]
 
     @classmethod
     def from_string(cls, input: str) -> "Environment":
@@ -3664,6 +3763,7 @@ class Environment(BaseModel):
         for k, v in self.concepts.items():
             if v.address == target.address:
                 v.pseudonyms.add(source.address)
+
             if v.address == source.address:
                 replacements[k] = target
                 v.pseudonyms.add(target.address)

trilogy/core/processing/concept_strategies_v3.py

@@ -539,11 +539,14 @@ def validate_concept(
             found_addresses.add(concept.address)
             found_map[str(node)].add(concept)
     for v_address in concept.pseudonyms:
+        if v_address in seen:
+            return
         v = environment.concepts[v_address]
-        if v == concept.address:
+        if v.address in seen:
             return
-        if v in seen:
+        if v.address == concept.address:
             return
+
         validate_concept(
             v,
             node,
@@ -866,6 +869,7 @@ def _search_concepts(
         )
         if complete == ValidationResult.INCOMPLETE_CONDITION:
             cond_dict = {str(node): node.preexisting_conditions for node in stack}
+            logger.error(f"Have {cond_dict} and need {str(conditions)}")
             raise SyntaxError(f"Have {cond_dict} and need {str(conditions)}")
         # early exit if we have a complete stack with one node
         # we can only early exit if we have a complete stack
@@ -987,17 +991,20 @@ def source_query_concepts(
         raise ValueError(
             f"Could not resolve conections between {error_strings} from environment graph."
         )
-    candidate = GroupNode(
-        output_concepts=[
-            x for x in root.output_concepts if x.address not in root.hidden_concepts
-        ],
-        input_concepts=[
-            x for x in root.output_concepts if x.address not in root.hidden_concepts
-        ],
+    final = [x for x in root.output_concepts if x.address not in root.hidden_concepts]
+    if GroupNode.check_if_required(
+        downstream_concepts=final,
+        parents=[root.resolve()],
         environment=environment,
-        parents=[root],
-        partial_concepts=root.partial_concepts,
-    )
-    if not candidate.resolve().group_required:
-        return root
+    ).required:
+        candidate: StrategyNode = GroupNode(
+            output_concepts=final,
+            input_concepts=final,
+            environment=environment,
+            parents=[root],
+            partial_concepts=root.partial_concepts,
+        )
+    else:
+        candidate = root
+
     return candidate

trilogy/core/processing/node_generators/basic_node.py

@@ -13,6 +13,7 @@ from trilogy.core.processing.node_generators.common import (
     resolve_function_parent_concepts,
 )
 from trilogy.core.processing.nodes import History, StrategyNode
+from trilogy.utility import unique
 
 LOGGER_PREFIX = "[GEN_BASIC_NODE]"
 
@@ -65,7 +66,9 @@ def gen_basic_node(
     non_equivalent_optional = [
         x for x in local_optional if x not in equivalent_optional
     ]
-    all_parents = parent_concepts + non_equivalent_optional
+    all_parents: list[Concept] = unique(
+        parent_concepts + non_equivalent_optional, "address"
+    )
     logger.info(
         f"{depth_prefix}{LOGGER_PREFIX} Fetching parents {[x.address for x in all_parents]}"
     )

trilogy/core/processing/node_generators/filter_node.py

@@ -60,7 +60,7 @@ def gen_filter_node(
         g=g,
         depth=depth + 1,
         history=history,
-        # conditions=conditions,
+        conditions=conditions,
     )
 
     flattened_existence = [x for y in parent_existence_concepts for x in y]
@@ -194,6 +194,9 @@ def gen_filter_node(
         history=history,
         conditions=conditions,
     )
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} returning filter node and enrich node with {enrich_node.output_concepts} and {enrich_node.input_concepts}"
+    )
     return MergeNode(
         input_concepts=[concept, immediate_parent] + local_optional,
         output_concepts=[
@@ -206,4 +209,5 @@ def gen_filter_node(
             filter_node,
             enrich_node,
         ],
+        preexisting_conditions=conditions.conditional if conditions else None,
     )

trilogy/core/processing/node_generators/group_to_node.py

@@ -26,6 +26,7 @@ def gen_group_to_node(
     # aggregates MUST always group to the proper grain
     if not isinstance(concept.lineage, Function):
         raise SyntaxError("Group to should have function lineage")
+    group_arg = concept.lineage.arguments[0]
     parent_concepts: List[Concept] = concept.lineage.concept_arguments
     logger.info(
         f"{padding(depth)}{LOGGER_PREFIX} group by node has required parents {[x.address for x in parent_concepts]}"
@@ -47,6 +48,13 @@ def gen_group_to_node(
         environment=environment,
         parents=parents,
         depth=depth,
+        preexisting_conditions=conditions.conditional if conditions else None,
+        hidden_concepts=(
+            [group_arg]
+            if isinstance(group_arg, Concept)
+            and group_arg.address not in local_optional
+            else []
+        ),
     )
 
     # early exit if no optional
@@ -62,6 +70,7 @@ def gen_group_to_node(
         g=g,
         depth=depth + 1,
         history=history,
+        conditions=conditions,
     )
     if not enrich_node:
         logger.info(
@@ -83,4 +92,5 @@ def gen_group_to_node(
         ],
         whole_grain=True,
         depth=depth,
+        preexisting_conditions=conditions.conditional if conditions else None,
     )

trilogy/core/processing/node_generators/multiselect_node.py

@@ -69,6 +69,7 @@ def gen_multiselect_node(
     lineage: MultiSelectStatement = concept.lineage
 
     base_parents: List[StrategyNode] = []
+    partial = []
     for select in lineage.selects:
         snode: StrategyNode = source_concepts(
             mandatory_list=select.output_components,
@@ -103,6 +104,9 @@ def gen_multiselect_node(
         for mc in merge_concepts:
             assert mc in snode.resolve().output_concepts
         base_parents.append(snode)
+        if select.where_clause:
+            for item in select.output_components:
+                partial.append(item)
 
     node_joins = extra_align_joins(lineage, base_parents)
     node = MergeNode(
@@ -112,35 +116,28 @@ def gen_multiselect_node(
         depth=depth,
         parents=base_parents,
         node_joins=node_joins,
+        hidden_concepts=[x for y in base_parents for x in y.hidden_concepts],
     )
 
     enrichment = set([x.address for x in local_optional])
 
-    rowset_relevant = [
+    multiselect_relevant = [
         x
         for x in lineage.derived_concepts
         if x.address == concept.address or x.address in enrichment
     ]
-    additional_relevant = [
-        x for x in select.output_components if x.address in enrichment
-    ]
+    additional_relevant = [x for x in node.output_concepts if x.address in enrichment]
     # add in other other concepts
-    for item in rowset_relevant:
-        node.output_concepts.append(item)
-    for item in additional_relevant:
-        node.output_concepts.append(item)
-    if select.where_clause:
-        for item in additional_relevant:
-            node.partial_concepts.append(item)
 
-    # we need a better API for refreshing a nodes QDS
-    node.resolution_cache = node._resolve()
+    node.set_output_concepts(multiselect_relevant + additional_relevant)
 
-    # assume grain to be output of select
-    # but don't include anything aggregate at this point
-    node.resolution_cache.grain = Grain.from_concepts(
-        node.output_concepts,
-    )
+    # node.add_partial_concepts(partial)
+    # if select.where_clause:
+    #     for item in additional_relevant:
+    #         node.partial_concepts.append(item)
+    node.grain = Grain.from_concepts(node.output_concepts, environment=environment)
+    node.rebuild_cache()
+    # we need a better API for refreshing a nodes QDS
     possible_joins = concept_to_relevant_joins(additional_relevant)
     if not local_optional:
         logger.info(
@@ -159,6 +156,7 @@ def gen_multiselect_node(
             f"{padding(depth)}{LOGGER_PREFIX} all enriched concepts returned from base rowset node; exiting early"
         )
         return node
+
     enrich_node: MergeNode = source_concepts(  # this fetches the parent + join keys
         # to then connect to the rest of the query
         mandatory_list=additional_relevant + local_optional,

trilogy/core/processing/node_generators/rowset_node.py

@@ -103,6 +103,7 @@ def gen_rowset_node(
         )
         return node
     if any(x.derivation == PurposeLineage.ROWSET for x in possible_joins):
+
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} cannot enrich rowset node with rowset concepts; exiting early"
         )

trilogy/core/processing/node_generators/select_merge_node.py

@@ -240,10 +240,12 @@ def create_datasource_node(
     depth: int,
     conditions: WhereClause | None = None,
 ) -> tuple[StrategyNode, bool]:
-    target_grain = Grain.from_concepts(all_concepts)
+    target_grain = Grain.from_concepts(all_concepts, environment=environment)
     force_group = False
     if not datasource.grain.issubset(target_grain):
         force_group = True
+    if not datasource.grain.components:
+        force_group = True
     partial_concepts = [
         c.concept
         for c in datasource.columns
@@ -350,6 +352,9 @@ def create_select_node(
 
     # we need to nest the group node one further
     if force_group is True:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} source requires group before consumption."
+        )
         candidate: StrategyNode = GroupNode(
             output_concepts=all_concepts,
             input_concepts=all_concepts,
@@ -359,8 +364,10 @@ def create_select_node(
             partial_concepts=bcandidate.partial_concepts,
             nullable_concepts=bcandidate.nullable_concepts,
             preexisting_conditions=bcandidate.preexisting_conditions,
+            force_group=force_group,
         )
     else:
+
         candidate = bcandidate
     return candidate
 

trilogy/core/processing/nodes/base_node.py

@@ -192,6 +192,8 @@ class StrategyNode:
         for x in self.parents:
             for z in x.usable_outputs:
                 non_hidden.add(z.address)
+                for psd in z.pseudonyms:
+                    non_hidden.add(psd)
         if not all([x.address in non_hidden for x in self.input_concepts]):
             missing = [x for x in self.input_concepts if x.address not in non_hidden]
             raise ValueError(
@@ -210,6 +212,8 @@ class StrategyNode:
         return self
 
     def add_condition(self, condition: Conditional | Comparison | Parenthetical):
+        if self.conditions and condition == self.conditions:
+            return self
         if self.conditions:
             self.conditions = Conditional(
                 left=self.conditions, right=condition, operator=BooleanOperator.AND
@@ -244,6 +248,15 @@ class StrategyNode:
             self.rebuild_cache()
         return self
 
+    def add_partial_concepts(self, concepts: List[Concept], rebuild: bool = True):
+        for concept in concepts:
+            if concept.address not in self.partial_lcl.addresses:
+                self.partial_concepts.append(concept)
+        self.partial_lcl = LooseConceptList(concepts=self.partial_concepts)
+        if rebuild:
+            self.rebuild_cache()
+        return self
+
     def add_existence_concepts(self, concepts: List[Concept], rebuild: bool = True):
         for concept in concepts:
             if concept.address not in self.output_concepts:

trilogy/core/processing/nodes/group_node.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from typing import List, Optional
 
 from trilogy.constants import logger
@@ -8,7 +9,6 @@ from trilogy.core.models import (
     Datasource,
     Environment,
     Grain,
-    LooseConceptList,
     Parenthetical,
     QueryDatasource,
     SourceType,
@@ -24,6 +24,13 @@ from trilogy.utility import unique
 LOGGER_PREFIX = "[CONCEPT DETAIL - GROUP NODE]"
 
 
+@dataclass
+class GroupRequiredResponse:
+    target: Grain
+    upstream: Grain
+    required: bool
+
+
 class GroupNode(StrategyNode):
     source_type = SourceType.GROUP
 
@@ -59,45 +66,44 @@ class GroupNode(StrategyNode):
             hidden_concepts=hidden_concepts,
         )
 
-    def _resolve(self) -> QueryDatasource:
-        parent_sources: List[QueryDatasource | Datasource] = [
-            p.resolve() for p in self.parents
-        ]
-
-        target_grain = self.grain or Grain.from_concepts(
+    @classmethod
+    def check_if_required(
+        cls,
+        downstream_concepts: List[Concept],
+        parents: list[QueryDatasource | Datasource],
+        environment: Environment,
+    ) -> GroupRequiredResponse:
+        target_grain = Grain.from_concepts(
             concepts_to_grain_concepts(
-                self.output_concepts, environment=self.environment
+                downstream_concepts,
+                environment=environment,
             )
         )
         comp_grain = Grain()
-        for source in parent_sources:
+        for source in parents:
             comp_grain += source.grain
         comp_grain = Grain.from_concepts(
-            concepts_to_grain_concepts(
-                comp_grain.components, environment=self.environment
-            )
+            concepts_to_grain_concepts(comp_grain.components, environment=environment)
         )
         # dynamically select if we need to group
         # because sometimes, we are already at required grain
-        if comp_grain == target_grain and self.force_group is not True:
-            # if there is no group by, and inputs equal outputs
-            # return the parent
-            logger.info(
-                f"{self.logging_prefix}{LOGGER_PREFIX} Grain of group by equals output"
-                f" grains {comp_grain} and {target_grain}"
-            )
-            if (
-                len(parent_sources) == 1
-                and LooseConceptList(concepts=parent_sources[0].output_concepts)
-                == self.output_lcl
-            ) and isinstance(parent_sources[0], QueryDatasource):
-                logger.info(
-                    f"{self.logging_prefix}{LOGGER_PREFIX} No group by required as inputs match outputs of parent; returning parent node"
-                )
-                will_return: QueryDatasource = parent_sources[0]
-                if self.conditions:
-                    will_return.condition = self.conditions + will_return.condition
-                return will_return
+        if comp_grain.issubset(target_grain):
+            return GroupRequiredResponse(target_grain, comp_grain, False)
+
+        return GroupRequiredResponse(target_grain, comp_grain, True)
+
+    def _resolve(self) -> QueryDatasource:
+        parent_sources: List[QueryDatasource | Datasource] = [
+            p.resolve() for p in self.parents
+        ]
+        grains = self.check_if_required(
+            self.output_concepts, parent_sources, self.environment
+        )
+        target_grain = grains.target
+        comp_grain = grains.upstream
+        # dynamically select if we need to group
+        # because sometimes, we are already at required grain
+        if not grains.required and self.force_group is not True:
             # otherwise if no group by, just treat it as a select
             source_type = SourceType.SELECT
         else:
@@ -108,15 +114,6 @@ class GroupNode(StrategyNode):
                 f" target grain {target_grain}"
                 f" delta: {comp_grain - target_grain}"
             )
-            for parent in self.parents:
-                logger.info(
-                    f"{self.logging_prefix}{LOGGER_PREFIX} Parent node"
-                    f" {[c.address for c in parent.output_concepts[:2]]}... has"
-                    " set node grain"
-                    f" {parent.grain}"
-                    f" and resolved grain {parent.resolve().grain}"
-                    f" {type(parent)}"
-                )
             source_type = SourceType.GROUP
         source_map = resolve_concept_map(
             parent_sources,

trilogy/core/processing/nodes/merge_node.py

@@ -224,9 +224,6 @@ class MergeNode(StrategyNode):
                 f"{self.logging_prefix}{LOGGER_PREFIX} Final joins is not null {final_joins} but is empty, skipping join generation"
             )
             return []
-
-        for join in joins:
-            logger.info(f"{self.logging_prefix}{LOGGER_PREFIX} final join {str(join)}")
         return joins
 
     def _resolve(self) -> QueryDatasource:
@@ -313,6 +310,7 @@ class MergeNode(StrategyNode):
         for join in joins:
             if isinstance(join, BaseJoin) and join.join_type == JoinType.FULL:
                 full_join_concepts += join.input_concepts
+
         if self.whole_grain:
             force_group = False
         elif self.force_group is False:

trilogy/core/processing/utility.py

@@ -306,11 +306,37 @@ def resolve_instantiated_concept(
     )
 
 
+def reduce_concept_pairs(input: list[ConceptPair]) -> list[ConceptPair]:
+    left_keys = set()
+    right_keys = set()
+    for pair in input:
+        if pair.left.purpose == Purpose.KEY:
+            left_keys.add(pair.left.address)
+        if pair.right.purpose == Purpose.KEY:
+            right_keys.add(pair.right.address)
+    final: list[ConceptPair] = []
+    for pair in input:
+        if (
+            pair.left.purpose == Purpose.PROPERTY
+            and pair.left.keys
+            and pair.left.keys.issubset(left_keys)
+        ):
+            continue
+        if (
+            pair.right.purpose == Purpose.PROPERTY
+            and pair.right.keys
+            and pair.right.keys.issubset(right_keys)
+        ):
+            continue
+        final.append(pair)
+    return final
+
+
 def get_node_joins(
     datasources: List[QueryDatasource | Datasource],
     environment: Environment,
     # concepts:List[Concept],
-):
+) -> List[BaseJoin]:
     graph = nx.Graph()
     partials: dict[str, list[str]] = {}
     ds_node_map: dict[str, QueryDatasource | Datasource] = {}
@@ -321,6 +347,8 @@ def get_node_joins(
         graph.add_node(ds_node, type=NodeType.NODE)
         partials[ds_node] = [f"c~{c.address}" for c in datasource.partial_concepts]
         for concept in datasource.output_concepts:
+            if concept in datasource.hidden_concepts:
+                continue
             add_node_join_concept(
                 graph=graph,
                 concept=concept,
@@ -337,19 +365,21 @@ def get_node_joins(
             join_type=j.type,
             # preserve empty field for maps
             concepts=[] if not j.keys else None,
-            concept_pairs=[
-                ConceptPair(
-                    left=resolve_instantiated_concept(
-                        concept_map[concept], ds_node_map[k]
-                    ),
-                    right=resolve_instantiated_concept(
-                        concept_map[concept], ds_node_map[j.right]
-                    ),
-                    existing_datasource=ds_node_map[k],
-                )
-                for k, v in j.keys.items()
-                for concept in v
-            ],
+            concept_pairs=reduce_concept_pairs(
+                [
+                    ConceptPair(
+                        left=resolve_instantiated_concept(
+                            concept_map[concept], ds_node_map[k]
+                        ),
+                        right=resolve_instantiated_concept(
+                            concept_map[concept], ds_node_map[j.right]
+                        ),
+                        existing_datasource=ds_node_map[k],
+                    )
+                    for k, v in j.keys.items()
+                    for concept in v
+                ]
+            ),
         )
         for j in joins
     ]

trilogy/core/query_processor.py

@@ -359,7 +359,7 @@ def get_query_node(
         environment.concepts[k] = v
     graph = generate_graph(environment)
     logger.info(
-        f"{LOGGER_PREFIX} getting source datasource for query with filtering {statement.where_clause_category} and output {[str(c) for c in statement.output_components]}"
+        f"{LOGGER_PREFIX} getting source datasource for query with filtering {statement.where_clause_category} and grain {statement.grain}"
     )
     if not statement.output_components:
         raise ValueError(f"Statement has no output components {statement}")

trilogy/dialect/base.py

@@ -249,7 +249,9 @@ def safe_get_cte_value(coalesce, cte: CTE | UnionCTE, c: Concept, quote_char: st
     if isinstance(raw, list) and len(raw) == 1:
         rendered = cte.get_alias(c, raw[0])
         return f"{raw[0]}.{safe_quote(rendered, quote_char)}"
-    return coalesce([f"{x}.{safe_quote(cte.get_alias(c, x), quote_char)}" for x in raw])
+    return coalesce(
+        sorted([f"{x}.{safe_quote(cte.get_alias(c, x), quote_char)}" for x in raw])
+    )
 
 
 class BaseDialect:

trilogy/parsing/parse_engine.py

@@ -17,7 +17,6 @@ from lark.tree import Meta
 from pydantic import ValidationError
 
 from trilogy.constants import (
-    CONFIG,
     DEFAULT_NAMESPACE,
     NULL_VALUE,
     MagicConstants,
@@ -108,7 +107,6 @@ from trilogy.core.models import (
     StructType,
     SubselectComparison,
     TupleWrapper,
-    UndefinedConcept,
     WhereClause,
     Window,
     WindowItem,
@@ -1030,81 +1028,15 @@ class ParseToObjects(Transformer):
         if not select_items:
             raise ValueError("Malformed select, missing select items")
 
-        output = SelectStatement(
+        return SelectStatement.from_inputs(
+            environment=self.environment,
             selection=select_items,
+            order_by=order_by,
             where_clause=where,
             having_clause=having,
             limit=limit,
-            order_by=order_by,
             meta=Metadata(line_number=meta.line),
         )
-        for parse_pass in [
-            1,
-            2,
-        ]:
-            # the first pass will result in all concepts being defined
-            # the second will get grains appropriately
-            # eg if someone does sum(x)->a, b+c -> z - we don't know if Z is a key to group by or an aggregate
-            # until after the first pass, and so don't know the grain of a
-
-            if parse_pass == 1:
-                grain = Grain.from_concepts(
-                    [
-                        x.content
-                        for x in output.selection
-                        if isinstance(x.content, Concept)
-                    ],
-                    where_clause=output.where_clause,
-                )
-            if parse_pass == 2:
-                grain = Grain.from_concepts(
-                    output.output_components, where_clause=output.where_clause
-                )
-            output.grain = grain
-            for item in select_items:
-                # we don't know the grain of an aggregate at assignment time
-                # so rebuild at this point in the tree
-                # TODO: simplify
-                if isinstance(item.content, ConceptTransform):
-                    new_concept = item.content.output.with_select_context(
-                        output.local_concepts,
-                        output.grain,
-                        environment=self.environment,
-                    )
-                    output.local_concepts[new_concept.address] = new_concept
-                    item.content.output = new_concept
-                    if parse_pass == 2 and CONFIG.select_as_definition:
-                        self.environment.add_concept(new_concept)
-                elif isinstance(item.content, UndefinedConcept):
-                    self.environment.concepts.raise_undefined(
-                        item.content.address,
-                        line_no=item.content.metadata.line_number,
-                        file=self.token_address,
-                    )
-                elif isinstance(item.content, Concept):
-                    # Sometimes cached values here don't have the latest info
-                    # but we can't just use environment, as it might not have the right grain.
-                    item.content = item.content.with_select_context(
-                        output.local_concepts,
-                        output.grain,
-                        environment=self.environment,
-                    )
-                    output.local_concepts[item.content.address] = item.content
-
-        if order_by:
-            output.order_by = order_by.with_select_context(
-                local_concepts=output.local_concepts,
-                grain=output.grain,
-                environment=self.environment,
-            )
-        if output.having_clause:
-            output.having_clause = output.having_clause.with_select_context(
-                local_concepts=output.local_concepts,
-                grain=output.grain,
-                environment=self.environment,
-            )
-        output.validate_syntax(self.environment)
-        return output
 
     @v_args(meta=True)
     def address(self, meta: Meta, args):

trilogy/utility.py

@@ -1,5 +1,5 @@
 import hashlib
-from typing import Any, Callable, List, Union
+from typing import Callable, List, TypeVar, Union
 
 from trilogy.constants import DEFAULT_NAMESPACE
 
@@ -12,7 +12,10 @@ def string_to_hash(input: str) -> int:
     )
 
 
-def unique(inputs: List, property: Union[str, Callable]) -> List[Any]:
+UniqueArg = TypeVar("UniqueArg")
+
+
+def unique(inputs: List[UniqueArg], property: Union[str, Callable]) -> List[UniqueArg]:
     final = []
     dedupe = set()
     if isinstance(property, str):