pytrilogy 0.0.3.63__py3-none-any.whl → 0.0.3.65__py3-none-any.whl

{pytrilogy-0.0.3.63.dist-info → pytrilogy-0.0.3.65.dist-info}/METADATA

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

{pytrilogy-0.0.3.63.dist-info → pytrilogy-0.0.3.65.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytrilogy-0.0.3.63.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=xI7eP5BeauF-VTS4qQZOvUQEsrA4bRoiDjyUkW0jbZk,303
+pytrilogy-0.0.3.65.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=5PSTzzhWYk76xlzO_XJek4S4HFPOp41QHzTT_y75mqk,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=lv_aJWP6dn6e2aF4BAE72jbnNtceFddfqtiDSsvzno0,1692
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
@@ -17,27 +17,27 @@ trilogy/core/environment_helpers.py,sha256=VvPIiFemqaLLpIpLIqprfu63K7muZ1YzNg7UZ
 trilogy/core/ergonomics.py,sha256=e-7gE29vPLFdg0_A1smQ7eOrUwKl5VYdxRSTddHweRA,1631
 trilogy/core/exceptions.py,sha256=JPYyBcit3T_pRtlHdtKSeVJkIyWUTozW2aaut25A2xI,673
 trilogy/core/functions.py,sha256=poVfAwet1xdxTkC7WL38UmGRDpUVO9iSMNWSagl9_r4,29302
-trilogy/core/graph_models.py,sha256=z17EoO8oky2QOuO6E2aMWoVNKEVJFhLdsQZOhC4fNLU,2079
+trilogy/core/graph_models.py,sha256=wIT-oBchHWE46GLDkgN5K7EzhOBEo8LfaeWV5G5cYcE,3302
 trilogy/core/internal.py,sha256=iicDBlC6nM8d7e7jqzf_ZOmpUsW8yrr2AA8AqEiLx-s,1577
 trilogy/core/optimization.py,sha256=ojpn-p79lr03SSVQbbw74iPCyoYpDYBmj1dbZ3oXCjI,8860
 trilogy/core/query_processor.py,sha256=QiE_w5HgheT4GLZFnaLssJ4plf4voK0TeTd6N3jhR6A,20188
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/models/author.py,sha256=8XbIsQr6cQrgo9uzee5qRoYiMdEG7yKF4FiiWImW7U0,77490
-trilogy/core/models/build.py,sha256=VAJpmk3GQCeJHpgjbFYHDXnFZlSD89sb0RvtIsZ58JE,63129
+trilogy/core/models/build.py,sha256=80v9rxwl41O8_7uIJoHK4tnTUfgR6u8EPrwHg4ySqO4,63323
 trilogy/core/models/build_environment.py,sha256=s_C9xAHuD3yZ26T15pWVBvoqvlp2LdZ8yjsv2_HdXLk,5363
 trilogy/core/models/core.py,sha256=EMAuWTngoNVGCdfNrAY7_k6g528iodNQLwPRVip-8DA,10980
 trilogy/core/models/datasource.py,sha256=6RjJUd2u4nYmEwFBpJlM9LbHVYDv8iHJxqiBMZqUrwI,9422
-trilogy/core/models/environment.py,sha256=tM8SwH9r1ZSc-F0Enod7r1NuqzGpQfLcPxnrtK5Hqpk,27398
-trilogy/core/models/execute.py,sha256=hOilC-lka4W-C8Pakb0Vd1-T0oskeWdC8Ls0bm8_388,43109
+trilogy/core/models/environment.py,sha256=7bkxUob5pNgvK7Om-qvlJgsDiCh5iSPlMHI7tN_OZhU,27717
+trilogy/core/models/execute.py,sha256=94CZVY_EdW675n8SihDnhaGTV0dq7BAAsl2Anf1mPmk,41815
 trilogy/core/optimizations/__init__.py,sha256=YH2-mGXZnVDnBcWVi8vTbrdw7Qs5TivG4h38rH3js_I,290
 trilogy/core/optimizations/base_optimization.py,sha256=gzDOKImoFn36k7XBD3ysEYDnbnb6vdVIztUfFQZsGnM,513
 trilogy/core/optimizations/inline_datasource.py,sha256=2sWNRpoRInnTgo9wExVT_r9RfLAQHI57reEV5cGHUcg,4329
 trilogy/core/optimizations/predicate_pushdown.py,sha256=g4AYE8Aw_iMlAh68TjNXGP754NTurrDduFECkUjoBnc,9399
 trilogy/core/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/processing/concept_strategies_v3.py,sha256=KHpSQyG5Ubb5H1dmzpDWI2ypJL_rxeS3zc3sjaeCq_s,21997
+trilogy/core/processing/concept_strategies_v3.py,sha256=uD_Bzy2l30TJ5-6v0tn9dO-vI6zFRgtHsIHUvge3Sps,22536
 trilogy/core/processing/discovery_loop.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/processing/discovery_node_factory.py,sha256=LFGHUznUz_kszcs8QywZ0pNaejbRoNVHv81gX6Mqm2Y,14909
+trilogy/core/processing/discovery_node_factory.py,sha256=X3-ywUvGbbcwwWtMqKXsPc6xyh3o41eiLRuByXGCvY4,14915
 trilogy/core/processing/discovery_utility.py,sha256=hF3aUbRHHZFeFT5aBjE6TuSeU60I90gzmj512QXG_t8,4856
 trilogy/core/processing/discovery_validation.py,sha256=Ek9jviFgimLMUMYLXBChUQmOD94ihhwQ3NDVe6RTdWg,4930
 trilogy/core/processing/graph_utils.py,sha256=8QUVrkE9j-9C1AyrCb1nQEh8daCe0u1HuXl-Te85lag,1205
@@ -49,18 +49,18 @@ trilogy/core/processing/node_generators/filter_node.py,sha256=0hdfiS2I-Jvr6P-il3
 trilogy/core/processing/node_generators/group_node.py,sha256=nIfiMrJQEksUfqAeeA3X5PS1343y4lmPTipYuCa-rvs,6141
 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=1vUmNE0qQQ1MYAvC6TO2dNsudIUytj9ZVcW4w1IGHXY,16734
+trilogy/core/processing/node_generators/node_merge_node.py,sha256=-sVhRHB3NqNIOk_e7LLVhW17Rjcf82hxaHjEvpF5Q-w,16858
 trilogy/core/processing/node_generators/recursive_node.py,sha256=l5zdh0dURKwmAy8kK4OpMtZfyUEQRk6N-PwSWIyBpSM,2468
 trilogy/core/processing/node_generators/rowset_node.py,sha256=2BiSsegbRF9csJ_Xl8P_CxIm4dAAb7dF29u6v_Odr-A,6709
-trilogy/core/processing/node_generators/select_merge_node.py,sha256=lxXhMhDKGbu67QFNbbAT-BO8gbWppIvjn_hAXpLEPe0,19953
+trilogy/core/processing/node_generators/select_merge_node.py,sha256=3GDGi1tNIfuKO_FMrNCfp-G1c3lxdRuuufcmomYLt4s,21446
 trilogy/core/processing/node_generators/select_node.py,sha256=3dvw0d53eUtCRCUPN6J48I3qBEX1Wha7saQ_ndPu6_I,1777
-trilogy/core/processing/node_generators/synonym_node.py,sha256=QNAMUknGPKRXkh5M_cQrff3b5B68KNcLxt1WHs8wBy4,3496
+trilogy/core/processing/node_generators/synonym_node.py,sha256=CN2swdGPEP_Irx4GykHp4gyLCK0dWd2vX7PYJUGxw7w,3548
 trilogy/core/processing/node_generators/union_node.py,sha256=VNo6Oey4p8etU9xrOh2oTT2lIOTvY6PULUPRvVa2uxU,2877
 trilogy/core/processing/node_generators/unnest_node.py,sha256=ueOQtoTf2iJHO09RzWHDFQ5iKZq2fVhGf2KAF2U2kU8,2677
 trilogy/core/processing/node_generators/window_node.py,sha256=GP3Hvkbb0TDA6ef7W7bmvQEHVH-NRIfBT_0W4fcH3g4,6529
 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=GMW07bb6hXurhF0hZLYoMAKSIS65tat5hwBjvqqPeSA,6516
-trilogy/core/processing/nodes/__init__.py,sha256=97eFwBa9vBhhXszgO-9JVxUzejKKeSHG6DilxRCWRm0,6083
+trilogy/core/processing/node_generators/select_helpers/datasource_injection.py,sha256=Dw0pjdhuJX0p-18CjelLrIJoevAPKzZOTN9uSLNPOF4,6553
+trilogy/core/processing/nodes/__init__.py,sha256=zTge1EzwzEydlcMliIFO_TT7h7lS8l37lyZuQDir1h0,5487
 trilogy/core/processing/nodes/base_node.py,sha256=p6yljFNLQsXz277c5wTATMNqsKUbsdP_3e7--tezBMw,17691
 trilogy/core/processing/nodes/filter_node.py,sha256=5VtRfKbCORx0dV-vQfgy3gOEkmmscL9f31ExvlODwvY,2461
 trilogy/core/processing/nodes/group_node.py,sha256=4EbOur1wSsOpPvP6znHih126o6A-TWbBXyvhiw5B0rs,10505
@@ -71,12 +71,12 @@ trilogy/core/processing/nodes/union_node.py,sha256=fDFzLAUh5876X6_NM7nkhoMvHEdGJ
 trilogy/core/processing/nodes/unnest_node.py,sha256=oLKMMNMx6PLDPlt2V5neFMFrFWxET8r6XZElAhSNkO0,2181
 trilogy/core/processing/nodes/window_node.py,sha256=JXJ0iVRlSEM2IBr1TANym2RaUf_p5E_l2sNykRzXWDo,1710
 trilogy/core/statements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/statements/author.py,sha256=PES6GPOAt90EOb6pSJol7A_ChTSUuj740TOO60PG0Wg,15400
+trilogy/core/statements/author.py,sha256=6cGCuKERNkH22T6iTsgoNp5CcIFwknF3WX-UmegbUPA,15409
 trilogy/core/statements/build.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/statements/common.py,sha256=KxEmz2ySySyZ6CTPzn0fJl5NX2KOk1RPyuUSwWhnK1g,759
 trilogy/core/statements/execute.py,sha256=rqfuoMuXPcH7L7TmE1dSiZ_K_A1ohB8whVMfGimZBOk,1294
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=CVOkIm3pwcuWlPGRqiimXjoKfns-2dAYlGsMCHGuzY4,43036
+trilogy/dialect/base.py,sha256=fM5tPJA5yi6tTHUTWpHldh4RApJUmrosDorbrRQibe4,43613
 trilogy/dialect/bigquery.py,sha256=6ghCqy-k7UioIJc1EEQ7gRo_PHaO8Vm7yYbiQ-kgpzs,3629
 trilogy/dialect/common.py,sha256=hhzuMTFW9QQIP7TKLT9BlJy6lw2R03a68jKQ-7t4-2c,6070
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
@@ -89,16 +89,16 @@ trilogy/dialect/snowflake.py,sha256=LQIcHuyuGZXbxrv6sH17aLXLzw7yFVuRoE9M4doNk5k,
 trilogy/dialect/sql_server.py,sha256=z2Vg7Qvw83rbGiEFIvHHLqVWJTWiz2xs76kpQj4HdTU,3131
 trilogy/hooks/__init__.py,sha256=T3SF3phuUDPLXKGRVE_Lf9mzuwoXWyaLolncR_1kY30,144
 trilogy/hooks/base_hook.py,sha256=I_l-NBMNC7hKTDx1JgHZPVOOCvLQ36m2oIGaR5EUMXY,1180
-trilogy/hooks/graph_hook.py,sha256=c-vC-IXoJ_jDmKQjxQyIxyXPOuUcLIURB573gCsAfzQ,2940
+trilogy/hooks/graph_hook.py,sha256=5BfR7Dt0bgEsCLgwjowgCsVkboGYfVJGOz8g9mqpnos,4756
 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=OOAssbo6Yp3L4u2OSGUYIuC_iAG_843vLpUtLkk1ub8,29960
+trilogy/parsing/common.py,sha256=yuKN3fQEtftRMZlJb0ESUX4TLOVFcAE0vw2CfImYG1A,29980
 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=O7aM5nZ4SjKlqO2x8XWefI1BMCW06jYYLhABU4k1HCI,72430
-trilogy/parsing/render.py,sha256=xUhG0gw4atYFO79kKL_U5UkHMma-oorN5vjPJ5zTBdU,19383
+trilogy/parsing/render.py,sha256=gGCFj2ue0UoaU2MR6qHGMAHXkYRMkTmHjnBowdcgFMY,19603
 trilogy/parsing/trilogy.lark,sha256=x9D1BXtE1E9Kxatx5Kt7xCaid8zgedabwca_B7j7L7o,14331
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=1L0XrH4mVHRt1C9T1HnaDv2_kYEfbWTb5_-cBBke79w,3774
@@ -110,8 +110,8 @@ trilogy/std/money.preql,sha256=XWwvAV3WxBsHX9zfptoYRnBigcfYwrYtBHXTME0xJuQ,2082
 trilogy/std/net.preql,sha256=-bMV6dyofskl4Kvows-iQ4JCxjVUwsZOeWCy8JO5Ftw,135
 trilogy/std/ranking.preql,sha256=LDoZrYyz4g3xsII9XwXfmstZD-_92i1Eox1UqkBIfi8,83
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.63.dist-info/METADATA,sha256=_iY3_JWL-W2VdevN6O37KO4VTlRsftF8w2n3Qqk9fxw,9095
-pytrilogy-0.0.3.63.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrilogy-0.0.3.63.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.63.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.63.dist-info/RECORD,,
+pytrilogy-0.0.3.65.dist-info/METADATA,sha256=EzLG1grru3E83dGL_4EkZemWzM8QDjCe-S08QQNVAmk,9095
+pytrilogy-0.0.3.65.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrilogy-0.0.3.65.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.65.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.65.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.63"
+__version__ = "0.0.3.65"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/graph_models.py

@@ -1,6 +1,50 @@
 import networkx as nx
 
-from trilogy.core.models.build import BuildConcept, BuildDatasource
+from trilogy.core.models.build import BuildConcept, BuildDatasource, BuildWhereClause
+
+
+def get_graph_exact_match(
+    g: nx.DiGraph, conditions: BuildWhereClause | None
+) -> set[str]:
+    datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
+        nx.get_node_attributes(g, "datasource")
+    )
+    exact: set[str] = set()
+    for node in g.nodes:
+        if node in datasources:
+            ds = datasources[node]
+            if isinstance(ds, list):
+                exact.add(node)
+                continue
+
+            if not conditions and not ds.non_partial_for:
+                exact.add(node)
+                continue
+            elif conditions:
+                if not ds.non_partial_for:
+                    continue
+                if ds.non_partial_for and conditions == ds.non_partial_for:
+                    exact.add(node)
+                    continue
+            else:
+                continue
+
+    return exact
+
+
+def prune_sources_for_conditions(
+    g: nx.DiGraph,
+    conditions: BuildWhereClause | None,
+):
+
+    complete = get_graph_exact_match(g, conditions)
+    to_remove = []
+    for node in g.nodes:
+        if node.startswith("ds~") and node not in complete:
+            to_remove.append(node)
+
+    for node in to_remove:
+        g.remove_node(node)
 
 
 def concept_to_node(input: BuildConcept) -> str:

trilogy/core/models/build.py

@@ -1586,7 +1586,10 @@ class Factory:
 
                 return BuildFunction.model_construct(
                     operator=base.operator,
-                    arguments=[rval, *[self.build(c) for c in raw_args[1:]]],
+                    arguments=[
+                        rval,
+                        *[self.handle_constant(self.build(c)) for c in raw_args[1:]],
+                    ],
                     output_datatype=base.output_datatype,
                     output_purpose=base.output_purpose,
                     valid_inputs=base.valid_inputs,
@@ -2042,4 +2045,6 @@ class Factory:
             and base.lineage.operator == FunctionType.CONSTANT
         ):
             return BuildParamaterizedConceptReference(concept=base)
+        elif isinstance(base, ConceptRef):
+            return self.handle_constant(self.build(base))
         return base

trilogy/core/models/environment.py

@@ -603,7 +603,7 @@ class Environment(BaseModel):
             # too hacky for maintainability
             if current_derivation not in (Derivation.ROOT, Derivation.CONSTANT):
                 logger.info(
-                    f"A datasource has been added which will persist derived concept {new_persisted_concept.address}"
+                    f"A datasource has been added which will persist derived concept {new_persisted_concept.address} with derivation {current_derivation}"
                 )
                 persisted = f"{PERSISTED_CONCEPT_PREFIX}_" + new_persisted_concept.name
                 # override the current concept source to reflect that it's now coming from a datasource
@@ -622,17 +622,21 @@ class Environment(BaseModel):
                         meta=meta,
                         force=True,
                     )
+                    base = {
+                        "lineage": None,
+                        "metadata": new_persisted_concept.metadata.model_copy(
+                            update={"concept_source": ConceptSource.PERSIST_STATEMENT}
+                        ),
+                        "derivation": Derivation.ROOT,
+                        "purpose": new_persisted_concept.purpose,
+                    }
+                    # purpose is used in derivation calculation
+                    # which should be fixed, but we'll do in a followup
+                    # so override here
+                    if new_persisted_concept.purpose == Purpose.CONSTANT:
+                        base["purpose"] = Purpose.KEY
                     new_persisted_concept = new_persisted_concept.model_copy(
-                        deep=True,
-                        update={
-                            "lineage": None,
-                            "metadata": new_persisted_concept.metadata.model_copy(
-                                update={
-                                    "concept_source": ConceptSource.PERSIST_STATEMENT
-                                }
-                            ),
-                            "derivation": Derivation.ROOT,
-                        },
+                        deep=True, update=base
                     )
                     self.add_concept(
                         new_persisted_concept,

trilogy/core/models/execute.py

@@ -56,6 +56,12 @@ LOGGER_PREFIX = "[MODELS_EXECUTE]"
 DATASOURCE_TYPES = (BuildDatasource, BuildDatasource)
 
 
+class InlinedCTE(BaseModel):
+    original_alias: str
+    new_alias: str
+    new_base: str
+
+
 class CTE(BaseModel):
     name: str
     source: "QueryDatasource"
@@ -78,6 +84,7 @@ class CTE(BaseModel):
     limit: Optional[int] = None
     base_name_override: Optional[str] = None
     base_alias_override: Optional[str] = None
+    inlined_ctes: dict[str, InlinedCTE] = Field(default_factory=dict)
 
     @field_validator("join_derived_concepts")
     def validate_join_derived_concepts(cls, v):
@@ -104,62 +111,6 @@ class CTE(BaseModel):
     def validate_output_columns(cls, v):
         return unique(v, "address")
 
-    def inline_constant(self, concept: BuildConcept):
-        if not concept.derivation == Derivation.CONSTANT:
-            return False
-        if not isinstance(concept.lineage, BuildFunction):
-            return False
-        if not concept.lineage.operator == FunctionType.CONSTANT:
-            return False
-        # remove the constant
-        removed: set = set()
-        if concept.address in self.source_map:
-            removed = removed.union(self.source_map[concept.address])
-            del self.source_map[concept.address]
-
-        if self.condition:
-            self.condition = self.condition.inline_constant(concept)
-        # if we've entirely removed the need to join to someplace to get the concept
-        # drop the join as well.
-        for removed_cte in removed:
-            still_required = any(
-                [
-                    removed_cte in x
-                    for x in self.source_map.values()
-                    or self.existence_source_map.values()
-                ]
-            )
-            if not still_required:
-                self.joins = [
-                    join
-                    for join in self.joins
-                    if not isinstance(join, Join)
-                    or (
-                        isinstance(join, Join)
-                        and (
-                            join.right_cte.name != removed_cte
-                            and any(
-                                [
-                                    x.cte.name != removed_cte
-                                    for x in (join.joinkey_pairs or [])
-                                ]
-                            )
-                        )
-                    )
-                ]
-                for join in self.joins:
-                    if isinstance(join, UnnestJoin) and concept in join.concepts:
-                        join.rendering_required = False
-
-                self.parent_ctes = [
-                    x for x in self.parent_ctes if x.name != removed_cte
-                ]
-                if removed_cte == self.base_name_override:
-                    candidates = [x.name for x in self.parent_ctes]
-                    self.base_name_override = candidates[0] if candidates else None
-                    self.base_alias_override = candidates[0] if candidates else None
-        return True
-
     @property
     def comment(self) -> str:
         base = f"Target: {str(self.grain)}. Group: {self.group_to_grain}"
@@ -240,7 +191,18 @@ class CTE(BaseModel):
                 ]
             elif v == parent.safe_identifier:
                 self.source_map[k] = [ds_being_inlined.safe_identifier]
-
+        for k, v in self.existence_source_map.items():
+            if isinstance(v, list):
+                self.existence_source_map[k] = [
+                    (
+                        ds_being_inlined.safe_identifier
+                        if x == parent.safe_identifier
+                        else x
+                    )
+                    for x in v
+                ]
+            elif v == parent.safe_identifier:
+                self.existence_source_map[k] = [ds_being_inlined.safe_identifier]
         # zip in any required values for lookups
         for k in ds_being_inlined.output_lcl.addresses:
             if k in self.source_map and self.source_map[k]:
@@ -251,6 +213,11 @@ class CTE(BaseModel):
         ]
         if force_group:
             self.group_to_grain = True
+        self.inlined_ctes[ds_being_inlined.safe_identifier] = InlinedCTE(
+            original_alias=parent.name,
+            new_alias=ds_being_inlined.safe_identifier,
+            new_base=ds_being_inlined.safe_location,
+        )
         return True
 
     def __add__(self, other: "CTE" | "UnionCTE"):
@@ -303,6 +270,10 @@ class CTE(BaseModel):
             **self.existence_source_map,
             **other.existence_source_map,
         }
+        self.inlined_ctes = {
+            **self.inlined_ctes,
+            **other.inlined_ctes,
+        }
 
         return self
 
@@ -672,7 +643,7 @@ class QueryDatasource(BaseModel):
                     and CONFIG.validate_missing
                 ):
                     raise SyntaxError(
-                        f"On query datasource from {values} missing source map entry (map: {v}) for {concept.address} on {key} with pseudonyms {concept.pseudonyms}, have {v}"
+                        f"Missing source map entry for {concept.address} on {key} with pseudonyms {concept.pseudonyms}, have map: {v}"
                     )
         return v
 
@@ -1057,6 +1028,7 @@ class UnionCTE(BaseModel):
     hidden_concepts: set[str] = Field(default_factory=set)
     partial_concepts: list[BuildConcept] = Field(default_factory=list)
     existence_source_map: Dict[str, list[str]] = Field(default_factory=dict)
+    inlined_ctes: Dict[str, InlinedCTE] = Field(default_factory=dict)
 
     @computed_field  # type: ignore
     @property

trilogy/core/processing/concept_strategies_v3.py

@@ -54,11 +54,7 @@ def generate_candidates_restrictive(
     exhausted: set[str],
     depth: int,
     conditions: BuildWhereClause | None = None,
-) -> List[BuildConcept]:
-    # if it's single row, joins are irrelevant. Fetch without keys.
-    if priority_concept.granularity == Granularity.SINGLE_ROW:
-        return []
-
+) -> tuple[list[BuildConcept], BuildWhereClause | None]:
     local_candidates = [
         x
         for x in list(candidates)
@@ -71,8 +67,16 @@ def generate_candidates_restrictive(
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Injecting additional conditional row arguments as all remaining concepts are roots or constant"
         )
-        return unique(list(conditions.row_arguments) + local_candidates, "address")
-    return local_candidates
+        # otherwise, we can ignore the conditions now that we've injected inputs
+        return (
+            unique(list(conditions.row_arguments) + local_candidates, "address"),
+            None,
+        )
+    # if it's single row, joins are irrelevant. Fetch without keys.
+    if priority_concept.granularity == Granularity.SINGLE_ROW:
+        return [], conditions
+
+    return local_candidates, conditions
 
 
 def append_existence_check(
@@ -104,9 +108,7 @@ def append_existence_check(
             )
             assert parent, "Could not resolve existence clause"
             node.add_parents([parent])
-            logger.info(
-                f"{LOGGER_PREFIX} fetching existence clause inputs {[str(c) for c in subselect]}"
-            )
+            logger.info(f"{LOGGER_PREFIX} found {[str(c) for c in subselect]}")
             node.add_existence_concepts([*subselect])
 
 
@@ -440,7 +442,19 @@ def _search_concepts(
     accept_partial: bool = False,
     conditions: BuildWhereClause | None = None,
 ) -> StrategyNode | None:
+    # check for direct materialization first
+    candidate = history.gen_select_node(
+        mandatory_list,
+        environment,
+        g,
+        depth + 1,
+        fail_if_not_found=False,
+        accept_partial=accept_partial,
+        conditions=conditions,
+    )
 
+    if candidate:
+        return candidate
     context = initialize_loop_context(
         mandatory_list=mandatory_list,
         environment=environment,
@@ -460,19 +474,21 @@ def _search_concepts(
         )
 
         local_conditions = evaluate_loop_conditions(context, priority_concept)
-        logger.info(
-            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} priority concept is {str(priority_concept)} derivation {priority_concept.derivation} granularity {priority_concept.granularity} with conditions {local_conditions}"
-        )
 
         candidates = [
             c for c in context.mandatory_list if c.address != priority_concept.address
         ]
-        candidate_list = generate_candidates_restrictive(
+        # the local conditions list may be override if we end up injecting conditions
+        candidate_list, local_conditions = generate_candidates_restrictive(
             priority_concept,
             candidates,
             context.skip,
             depth=depth,
-            conditions=context.conditions,
+            conditions=local_conditions,
+        )
+
+        logger.info(
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} priority concept is {str(priority_concept)} derivation {priority_concept.derivation} granularity {priority_concept.granularity} with conditions {local_conditions}"
         )
 
         logger.info(

trilogy/core/processing/discovery_node_factory.py

@@ -438,15 +438,14 @@ def generate_node(
     )
 
     # Try materialized concept first
+    # this is worth checking every loop iteration
     candidate = history.gen_select_node(
-        concept,
-        local_optional,
+        [concept] + local_optional,
         environment,
         g,
         depth + 1,
         fail_if_not_found=False,
         accept_partial=accept_partial,
-        accept_partial_optional=False,
         conditions=conditions,
     )
 

trilogy/core/processing/node_generators/node_merge_node.py

@@ -6,7 +6,7 @@ from networkx.algorithms import approximation as ax
 from trilogy.constants import logger
 from trilogy.core.enums import Derivation
 from trilogy.core.exceptions import AmbiguousRelationshipResolutionException
-from trilogy.core.graph_models import concept_to_node
+from trilogy.core.graph_models import concept_to_node, prune_sources_for_conditions
 from trilogy.core.models.build import BuildConcept, BuildConditional, BuildWhereClause
 from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.processing.nodes import History, MergeNode, StrategyNode
@@ -222,10 +222,12 @@ def resolve_weak_components(
     environment_graph: nx.DiGraph,
     filter_downstream: bool = True,
     accept_partial: bool = False,
+    search_conditions: BuildWhereClause | None = None,
 ) -> list[list[BuildConcept]] | None:
     break_flag = False
     found = []
     search_graph = environment_graph.copy()
+    prune_sources_for_conditions(search_graph, conditions=search_conditions)
     reduced_concept_sets: list[set[str]] = []
 
     # loop through, removing new nodes we find
@@ -239,7 +241,6 @@ def resolve_weak_components(
             if "__preql_internal" not in c.address
         ]
     )
-    logger.debug(f"Resolving weak components for {node_list} in {search_graph.nodes}")
     synonyms: set[str] = set()
     for x in all_concepts:
         synonyms = synonyms.union(x.pseudonyms)
@@ -407,6 +408,7 @@ def gen_merge_node(
             g,
             filter_downstream=filter_downstream,
             accept_partial=accept_partial,
+            search_conditions=search_conditions,
         )
         if not weak_resolve:
             logger.info(

trilogy/core/processing/node_generators/select_helpers/datasource_injection.py

@@ -169,7 +169,9 @@ def is_fully_covered(
     return current_end >= end
 
 
-def get_union_sources(datasources: list[BuildDatasource], concepts: list[BuildConcept]):
+def get_union_sources(
+    datasources: list[BuildDatasource], concepts: list[BuildConcept]
+) -> List[list[BuildDatasource]]:
     candidates: list[BuildDatasource] = []
     for x in datasources:
         if all([c.address in x.output_concepts for c in concepts]):

trilogy/core/processing/node_generators/select_merge_node.py

@@ -5,7 +5,11 @@ import networkx as nx
 
 from trilogy.constants import logger
 from trilogy.core.enums import Derivation
-from trilogy.core.graph_models import concept_to_node
+from trilogy.core.graph_models import (
+    concept_to_node,
+    get_graph_exact_match,
+    prune_sources_for_conditions,
+)
 from trilogy.core.models.build import (
     BuildConcept,
     BuildDatasource,
@@ -57,26 +61,6 @@ def get_graph_partial_nodes(
     return partial
 
 
-def get_graph_exact_match(
-    g: nx.DiGraph, conditions: BuildWhereClause | None
-) -> set[str]:
-    datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
-        nx.get_node_attributes(g, "datasource")
-    )
-    exact: set[str] = set()
-    for node in g.nodes:
-        if node in datasources:
-            ds = datasources[node]
-            if not isinstance(ds, list):
-                if ds.non_partial_for and conditions == ds.non_partial_for:
-                    exact.add(node)
-                    continue
-            else:
-                continue
-
-    return exact
-
-
 def get_graph_grains(g: nx.DiGraph) -> dict[str, list[str]]:
     datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
         nx.get_node_attributes(g, "datasource")
@@ -95,6 +79,34 @@ def get_graph_grains(g: nx.DiGraph) -> dict[str, list[str]]:
     return grain_length
 
 
+def subgraph_is_complete(
+    nodes: list[str], targets: set[str], mapping: dict[str, str], g: nx.DiGraph
+) -> bool:
+    mapped = set([mapping.get(n, n) for n in nodes])
+    passed = all([t in mapped for t in targets])
+    if not passed:
+        logger.info(
+            f"Subgraph {nodes} is not complete, missing targets {targets} - mapped {mapped}"
+        )
+        return False
+    # check if all concepts have a datasource edge
+    has_ds_edge = {
+        mapping.get(n, n): any(x.startswith("ds~") for x in nx.neighbors(g, n))
+        for n in nodes
+        if n.startswith("c~")
+    }
+    has_ds_edge = {k: False for k in targets}
+    # check at least one instance of concept has a datasource edge
+    for n in nodes:
+        if n.startswith("c~"):
+            neighbors = nx.neighbors(g, n)
+            for neighbor in neighbors:
+                if neighbor.startswith("ds~"):
+                    has_ds_edge[mapping.get(n, n)] = True
+                    break
+    return all(has_ds_edge.values()) and passed
+
+
 def create_pruned_concept_graph(
     g: nx.DiGraph,
     all_concepts: List[BuildConcept],
@@ -104,6 +116,7 @@ def create_pruned_concept_graph(
     depth: int = 0,
 ) -> nx.DiGraph:
     orig_g = g
+
     g = g.copy()
     union_options = get_union_sources(datasources, all_concepts)
     for ds_list in union_options:
@@ -114,7 +127,8 @@ def create_pruned_concept_graph(
         g.add_node(node_address, datasource=ds_list)
         for c in common:
             g.add_edge(node_address, concept_to_node(c))
-
+            g.add_edge(concept_to_node(c), node_address)
+    prune_sources_for_conditions(g, conditions)
     target_addresses = set([c.address for c in all_concepts])
     concepts: dict[str, BuildConcept] = nx.get_node_attributes(orig_g, "concept")
     datasource_map: dict[str, BuildDatasource | list[BuildDatasource]] = (
@@ -126,8 +140,7 @@ def create_pruned_concept_graph(
         # filter out synonyms
         if (x := concepts.get(n, None)) and x.address in target_addresses
     }
-    # from trilogy.hooks.graph_hook import GraphHook
-    # GraphHook().query_graph_built(g)
+
     relevant_concepts: list[str] = list(relevant_concepts_pre.keys())
     relevent_datasets: list[str] = []
     if not accept_partial:
@@ -149,6 +162,7 @@ def create_pruned_concept_graph(
                 to_remove.append(edge)
         for edge in to_remove:
             g.remove_edge(*edge)
+
     for n in g.nodes():
         if not n.startswith("ds~"):
             continue
@@ -181,8 +195,15 @@ def create_pruned_concept_graph(
             if n not in relevent_datasets and n not in relevant_concepts
         ]
     )
-
+    # from trilogy.hooks.graph_hook import GraphHook
+    # GraphHook().query_graph_built(g)
     subgraphs = list(nx.connected_components(g.to_undirected()))
+    subgraphs = [
+        s
+        for s in subgraphs
+        if subgraph_is_complete(s, target_addresses, relevant_concepts_pre, g)
+    ]
+
     if not subgraphs:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - no subgraphs after node prune"
@@ -486,6 +507,24 @@ def gen_select_merge_node(
     non_constant = [c for c in all_concepts if c.derivation != Derivation.CONSTANT]
     constants = [c for c in all_concepts if c.derivation == Derivation.CONSTANT]
     if not non_constant and constants:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} only constant inputs to discovery ({constants}), returning constant node directly"
+        )
+        for x in constants:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} {x} {x.lineage} {x.derivation}"
+            )
+        if conditions:
+            if not all(
+                [x.derivation == Derivation.CONSTANT for x in conditions.row_arguments]
+            ):
+                logger.info(
+                    f"{padding(depth)}{LOGGER_PREFIX} conditions being passed in to constant node {conditions}, but not all concepts are constants."
+                )
+                return None
+            else:
+                constants += conditions.row_arguments
+
         return ConstantNode(
             output_concepts=constants,
             input_concepts=[],
@@ -494,7 +533,7 @@ def gen_select_merge_node(
             depth=depth,
             partial_concepts=[],
             force_group=False,
-            preexisting_conditions=conditions.conditional if conditions else None,
+            conditions=conditions.conditional if conditions else None,
         )
     for attempt in [False, True]:
         pruned_concept_graph = create_pruned_concept_graph(

trilogy/core/processing/node_generators/synonym_node.py

@@ -50,7 +50,9 @@ def gen_synonym_node(
 
     logger.info(f"{local_prefix} Generating Synonym Node with {len(synonyms)} synonyms")
     sorted_keys = sorted(synonyms.keys())
-    combinations_list = list(itertools.product(*(synonyms[obj] for obj in sorted_keys)))
+    combinations_list: list[tuple[BuildConcept, ...]] = list(
+        itertools.product(*(synonyms[obj] for obj in sorted_keys))
+    )
 
     def similarity_sort_key(combo):
         addresses = [x.address for x in combo]
@@ -83,7 +85,7 @@ def gen_synonym_node(
             f"{local_prefix} checking combination {fingerprint} with {len(combo)} concepts"
         )
         attempt: StrategyNode | None = source_concepts(
-            combo,
+            list(combo),
             history=history,
             environment=environment,
             depth=depth,

trilogy/core/processing/nodes/__init__.py

@@ -124,51 +124,31 @@ class History(BaseModel):
             in self.started
         )
 
-    def _select_concepts_to_lookup(
-        self,
-        main: BuildConcept,
-        search: list[BuildConcept],
-        accept_partial: bool,
-        fail_if_not_found: bool,
-        accept_partial_optional: bool,
-        conditions: BuildWhereClause | None = None,
-    ) -> str:
-        return (
-            str(main.address)
-            + "|"
-            + "-".join([c.address for c in search])
-            + str(accept_partial)
-            + str(fail_if_not_found)
-            + str(accept_partial_optional)
-            + str(conditions)
-        )
-
     def gen_select_node(
         self,
-        concept: BuildConcept,
-        local_optional: list[BuildConcept],
+        concepts: list[BuildConcept],
         environment: BuildEnvironment,
         g,
         depth: int,
         fail_if_not_found: bool = False,
         accept_partial: bool = False,
-        accept_partial_optional: bool = False,
         conditions: BuildWhereClause | None = None,
     ) -> StrategyNode | None:
         from trilogy.core.processing.node_generators.select_node import gen_select_node
 
-        fingerprint = self._select_concepts_to_lookup(
-            concept,
-            local_optional,
+        fingerprint = self._concepts_to_lookup(
+            concepts,
             accept_partial,
-            fail_if_not_found,
-            accept_partial_optional=accept_partial_optional,
             conditions=conditions,
         )
         if fingerprint in self.select_history:
-            return self.select_history[fingerprint]
+            rval = self.select_history[fingerprint]
+            if rval:
+                # all nodes must be copied before returning
+                return rval.copy()
+            return rval
         gen = gen_select_node(
-            [concept] + local_optional,
+            concepts,
             environment,
             g,
             depth + 1,
@@ -177,6 +157,8 @@ class History(BaseModel):
             conditions=conditions,
         )
         self.select_history[fingerprint] = gen
+        if gen:
+            return gen.copy()
         return gen
 
 

trilogy/core/statements/author.py

@@ -448,7 +448,7 @@ class TypeDeclaration(BaseModel):
     type: CustomType
 
 
-class FunctionDeclaration(BaseModel):
+class FunctionDeclaration(HasUUID, BaseModel):
     name: str
     args: list[ArgBinding]
     expr: Expr

trilogy/dialect/base.py

@@ -58,6 +58,7 @@ from trilogy.core.query_processor import process_copy, process_persist, process_
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
     CopyStatement,
+    FunctionDeclaration,
     ImportStatement,
     MergeStatementV2,
     MultiSelectStatement,
@@ -579,7 +580,12 @@ class BaseDialect:
                     target = INVALID_REFERENCE_STRING(
                         f"Missing source CTE for {e.right.address}"
                     )
+                assert cte, "CTE must be provided for inlined CTEs"
+                if target in cte.inlined_ctes:
+                    info = cte.inlined_ctes[target]
+                    return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} {e.operator.value} (select {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {info.new_base} as {target} where {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} is not null)"
                 return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid)} {e.operator.value} (select {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} from {target} where {target}.{self.QUOTE_CHARACTER}{e.right.safe_address}{self.QUOTE_CHARACTER} is not null)"
+
             elif isinstance(
                 e.right,
                 (ListWrapper, TupleWrapper, BuildParenthetical, list),
@@ -980,6 +986,7 @@ class BaseDialect:
                     ImportStatement,
                     RowsetDerivationStatement,
                     Datasource,
+                    FunctionDeclaration,
                 ),
             ):
                 continue

trilogy/hooks/graph_hook.py

@@ -22,7 +22,6 @@ class GraphHook(BaseHook):
             pass
         except ImportError:
             raise ImportError("GraphHook requires matplotlib and scipy to be installed")
-
         # https://github.com/python/cpython/issues/125235#issuecomment-2412948604
 
     def query_graph_built(
@@ -39,8 +38,10 @@ class GraphHook(BaseHook):
         for node in nodes:
             if "__preql_internal" in node:
                 graph.remove_node(node)
+
         if remove_isolates:
             graph.remove_nodes_from(list(nx.isolates(graph)))
+
         color_map = []
         highlight_nodes = highlight_nodes or []
         for node in graph:
@@ -50,9 +51,10 @@ class GraphHook(BaseHook):
                 color_map.append("blue")
             else:
                 color_map.append("green")
-        # pos = nx.kamada_kawai_layout(graph, scale=2)
+
         pos = nx.spring_layout(graph)
         kwargs = {}
+
         if target:
             edge_colors = []
             descendents = nx.descendants(graph, target)
@@ -66,21 +68,72 @@ class GraphHook(BaseHook):
                 else:
                     edge_colors.append("black")
             kwargs["edge_color"] = edge_colors
+
+        # Draw the graph without labels first
         nx.draw(
             graph,
             pos=pos,
             node_color=color_map,
             connectionstyle="arc3, rad = 0.1",
+            with_labels=False,  # Important: don't draw labels with nx.draw
             **kwargs
-        )  # Draw the original graph
-        # Please note, the code below uses the original idea of re-calculating a dictionary of adjusted label positions per node.
+        )
+
+        # Draw labels with manual spacing
+        self._draw_labels_with_manual_spacing(graph, pos)
+
+        plt.show()
+
+    def _draw_labels_with_manual_spacing(self, graph, pos):
+        import numpy as np
+
         pos_labels = {}
-        # For each node in the Graph
-        for aNode in graph.nodes():
-            # Get the node's position from the layout
-            x, y = pos[aNode]
-            # pos_labels[aNode] = (x+slopeX*label_ratio, y+slopeY*label_ratio)
-            pos_labels[aNode] = (x, y)
-        # Finally, redraw the labels at their new position.
+        node_positions = list(pos.values())
+
+        # Calculate average distance between nodes to determine spacing
+        if len(node_positions) > 1:
+            distances = []
+            for i, (x1, y1) in enumerate(node_positions):
+                for j, (x2, y2) in enumerate(node_positions[i + 1 :], i + 1):
+                    dist = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+                    distances.append(dist)
+
+            avg_distance = np.mean(distances)
+            min_spacing = max(
+                0.1, avg_distance * 0.3
+            )  # Minimum spacing as fraction of average distance
+        else:
+            min_spacing = 0.1
+
+        # Simple spacing algorithm - offset labels that are too close
+        for i, node in enumerate(graph.nodes()):
+            x, y = pos[node]
+
+            # Check for nearby labels and adjust position
+            adjusted_x, adjusted_y = x, y
+            for j, other_node in enumerate(
+                list(graph.nodes())[:i]
+            ):  # Only check previous nodes
+                other_x, other_y = pos_labels.get(other_node, pos[other_node])
+                distance = np.sqrt(
+                    (adjusted_x - other_x) ** 2 + (adjusted_y - other_y) ** 2
+                )
+
+                if distance < min_spacing:
+                    # Calculate offset direction
+                    if distance > 0:
+                        offset_x = (adjusted_x - other_x) / distance * min_spacing
+                        offset_y = (adjusted_y - other_y) / distance * min_spacing
+                    else:
+                        # If nodes are at exact same position, use random offset
+                        angle = np.random.random() * 2 * np.pi
+                        offset_x = np.cos(angle) * min_spacing
+                        offset_y = np.sin(angle) * min_spacing
+
+                    adjusted_x = other_x + offset_x
+                    adjusted_y = other_y + offset_y
+
+            pos_labels[node] = (adjusted_x, adjusted_y)
+
+        # Draw the labels at adjusted positions
         nx.draw_networkx_labels(graph, pos=pos_labels, font_size=10)
-        plt.show()

trilogy/parsing/common.py

@@ -86,7 +86,7 @@ def process_function_arg(
         if concept.metadata and meta:
             concept.metadata.line_number = meta.line
         environment.add_concept(concept, meta=meta)
-        return concept
+        return concept.reference
     elif isinstance(
         arg,
         (ListWrapper, MapWrapper),
@@ -103,7 +103,7 @@ def process_function_arg(
         if concept.metadata and meta:
             concept.metadata.line_number = meta.line
         environment.add_concept(concept, meta=meta)
-        return concept
+        return concept.reference
     elif isinstance(arg, Concept):
         return arg.reference
     elif isinstance(arg, ConceptRef):

trilogy/parsing/render.py

@@ -506,7 +506,11 @@ class Renderer:
             return f"{args[0]} % {args[1]}"
         if arg.operator == FunctionType.PARENTHETICAL:
             return f"({args[0]})"
-
+        if arg.operator == FunctionType.GROUP:
+            arg_string = ", ".join(args[1:])
+            if len(args) == 1:
+                return f"group({args[0]})"
+            return f"group({args[0]}) by {arg_string}"
         inputs = ",".join(args)
 
         if arg.operator == FunctionType.CONSTANT: