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

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

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

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

@@ -1,9 +1,9 @@
-pytrilogy-0.0.3.88.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=cl4nRewdhba3xQodaj4EqSuH_HCoF56PNkWEO79F_VY,303
+pytrilogy-0.0.3.90.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=xsnAVhMdPDgMBudr3tOEYEMfxl0t6RWAK_231sFSxAU,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=eKb_EJvSqjN9tGbdVEViwdtwwh8fZ3-jpOEDqL71y70,1691
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
-trilogy/executor.py,sha256=iwrYs5hEaw2hTaNZOYW5Z0w6Va1RzdRpg5bn50tlslA,16731
+trilogy/executor.py,sha256=tcowEz8I7zbwLnuTr7BlGJ5wnt1JKBNffXbm5ywkNv8,17032
 trilogy/parser.py,sha256=o4cfk3j3yhUFoiDKq9ZX_GjBF3dKhDjXEwb63rcBkBM,293
 trilogy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/render.py,sha256=qQWwduymauOlB517UtM-VGbVe8Cswa4UJub5aGbSO6c,1512
@@ -16,17 +16,17 @@ trilogy/core/env_processor.py,sha256=pFsxnluKIusGKx1z7tTnfsd_xZcPy9pZDungkjkyvI0
 trilogy/core/environment_helpers.py,sha256=VvPIiFemqaLLpIpLIqprfu63K7muZ1YzNg7UZIUph8w,8267
 trilogy/core/ergonomics.py,sha256=e-7gE29vPLFdg0_A1smQ7eOrUwKl5VYdxRSTddHweRA,1631
 trilogy/core/exceptions.py,sha256=jYEduuMehcMkmCpf-OC_taELPZm7qNfeSNzIWkDYScs,707
-trilogy/core/functions.py,sha256=piMv91RiW1OAgDS5W8HIiO6fGleiNXIFW0YnNZgYOWU,32943
+trilogy/core/functions.py,sha256=hnfcNjAD-XQ572vEwuUEAdBf8zKFWYwPeHIpESjUpZs,32928
 trilogy/core/graph_models.py,sha256=BYhJzHKSgnZHVLJs1CfsgrxTPHqKqPNeA64RlozGY0A,3498
 trilogy/core/internal.py,sha256=wFx4e1I0mtx159YFShSXeUBSQ82NINtAbOI-92RX4i8,2151
 trilogy/core/optimization.py,sha256=ojpn-p79lr03SSVQbbw74iPCyoYpDYBmj1dbZ3oXCjI,8860
 trilogy/core/query_processor.py,sha256=5aFgv-2LVM1Uku9cR_tFuTRDwyLnxc95bCMAHeFy2AY,20332
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/models/author.py,sha256=5o0x9d3U_J2b8GPdJnMsMruC2P-xiI55lZKWUwRIeGU,78936
+trilogy/core/models/author.py,sha256=tcsr42hHiQ2PHh2_le9sr5IV5nv3twxUv2EXr5iDGxg,80201
 trilogy/core/models/build.py,sha256=CyrSo4xgU-uDKW3xUVYs5cTk3Z3Z2BMWdGQNHnHZOqU,66127
 trilogy/core/models/build_environment.py,sha256=s_C9xAHuD3yZ26T15pWVBvoqvlp2LdZ8yjsv2_HdXLk,5363
-trilogy/core/models/core.py,sha256=eSzrrscwTrlO_PIn9_UxKSPBgKgR9-xp90LY1e0lhN0,11538
+trilogy/core/models/core.py,sha256=NOvonI4Ip4thpz5WoJZWbbBa44PFfpd2hXGx2Cbi4CE,12521
 trilogy/core/models/datasource.py,sha256=wogTevZ-9CyUW2a8gjzqMCieircxi-J5lkI7EOAZnck,9596
 trilogy/core/models/environment.py,sha256=0IHSCFf5e5b4LPQN3vmjumtfM1iD1tN4WMoUr0UqxZI,27855
 trilogy/core/models/execute.py,sha256=sVWhjwWull-T6pUJizhrYVGCWHY3eZivVN6KNlhcHig,41839
@@ -46,7 +46,7 @@ trilogy/core/processing/node_generators/__init__.py,sha256=iVJ-crowPxYeut-hFjyEj
 trilogy/core/processing/node_generators/basic_node.py,sha256=TLZCv4WS196a-0g5xgKuJGthnGP8Ugm46iz85_3NIY4,5626
 trilogy/core/processing/node_generators/common.py,sha256=PdysdroW9DUADP7f5Wv_GKPUyCTROZV1g3L45fawxi8,9443
 trilogy/core/processing/node_generators/constant_node.py,sha256=LfpDq2WrBRZ3tGsLxw77LuigKfhbteWWh9L8BGdMGwk,1146
-trilogy/core/processing/node_generators/filter_node.py,sha256=oRRq2-T3ufgn4D23uQsc58f20eFk-djs4QI3WKA75K8,10908
+trilogy/core/processing/node_generators/filter_node.py,sha256=ArBsQJl-4fWBJWCE28CRQ7UT7ErnFfbcseoQQZrBodY,11220
 trilogy/core/processing/node_generators/group_node.py,sha256=1QJhRxsTklJ5xq8wHlAURZaN9gL9FPpeCa1OJ7IwXnY,6769
 trilogy/core/processing/node_generators/group_to_node.py,sha256=jKcNCDOY6fNblrdZwaRU0sbUSr9H0moQbAxrGgX6iGA,3832
 trilogy/core/processing/node_generators/multiselect_node.py,sha256=GWV5yLmKTe1yyPhN60RG1Rnrn4ktfn9lYYXi_FVU4UI,7061
@@ -77,8 +77,8 @@ trilogy/core/statements/build.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 trilogy/core/statements/common.py,sha256=KxEmz2ySySyZ6CTPzn0fJl5NX2KOk1RPyuUSwWhnK1g,759
 trilogy/core/statements/execute.py,sha256=pfr1CZ_Cx1qQ-7LDyRI0JUfvtxBr_GGv-VeqiAjr43g,1406
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=bkCJsJvUQLlrKzHCTbWlLikas5o-JluCVI12RSSbYuE,48228
-trilogy/dialect/bigquery.py,sha256=8xhEu0z_lKANjbvzvBbC7CeKrJf1iP8YyrHqNale-ug,4351
+trilogy/dialect/base.py,sha256=_L5wHBHz8v4Us3tu4QIupKuaObmyhWhyDuroT95wUbo,48228
+trilogy/dialect/bigquery.py,sha256=XS3hpybeowgfrOrkycAigAF3NX2YUzTzfgE6f__2fT4,4316
 trilogy/dialect/common.py,sha256=tSthIZOXXRPQ4KeMKnDDsH7KlTmf2EVqigVtLyoc4zc,6071
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
 trilogy/dialect/dataframe.py,sha256=RUbNgReEa9g3pL6H7fP9lPTrAij5pkqedpZ99D8_5AE,1522
@@ -98,7 +98,7 @@ trilogy/parsing/common.py,sha256=yV1AckK0h8u1OFeGQBTMu-wuW5m63c5CcZuPicsTH_w,306
 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=snT7m7LWrOHcSZlqdJ5HXWmH1wMMPDaqrsf6AQsMx70,79800
+trilogy/parsing/parse_engine.py,sha256=fgqCtV6sf9HrkViEjf6XXdRpPf4hJ1gSyzLXZ9sLBHs,80148
 trilogy/parsing/render.py,sha256=HSNntD82GiiwHT-TWPLXAaIMWLYVV5B5zQEsgwrHIBE,19605
 trilogy/parsing/trilogy.lark,sha256=ySzMMLxyPjn74MjFHZxXPTW-jHW68KLPJpiszPvZaO0,15780
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,8 +111,8 @@ trilogy/std/money.preql,sha256=XWwvAV3WxBsHX9zfptoYRnBigcfYwrYtBHXTME0xJuQ,2082
 trilogy/std/net.preql,sha256=WZCuvH87_rZntZiuGJMmBDMVKkdhTtxeHOkrXNwJ1EE,416
 trilogy/std/ranking.preql,sha256=LDoZrYyz4g3xsII9XwXfmstZD-_92i1Eox1UqkBIfi8,83
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.88.dist-info/METADATA,sha256=MJ92RHQZuHjfV6eUuy9Z_F7U3BBt4ilDIzrfkS_kzSg,9589
-pytrilogy-0.0.3.88.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrilogy-0.0.3.88.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.88.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.88.dist-info/RECORD,,
+pytrilogy-0.0.3.90.dist-info/METADATA,sha256=X046-UiVgiZTCb6DQXtQuzAe9Qm4DNTefqbNXixNx5g,9589
+pytrilogy-0.0.3.90.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrilogy-0.0.3.90.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.90.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.90.dist-info/RECORD,,

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

trilogy/core/functions.py

@@ -92,7 +92,7 @@ def get_attr_datatype(
     lookup = args[1]
     datatype = arg_to_datatype(arg)
     if isinstance(datatype, StructType):
-        return arg_to_datatype(datatype.fields_map[lookup])
+        return datatype.field_types[lookup]
     return datatype
 
 
@@ -935,6 +935,7 @@ class FunctionFactory:
                 output_purpose = Purpose.METRIC
             else:
                 output_purpose = Purpose.PROPERTY
+
         return Function(
             operator=operator,
             arguments=full_args,  # type: ignore

trilogy/core/models/author.py

@@ -172,11 +172,16 @@ class ConceptRef(Addressable, Namespaced, DataTyped, Mergeable, BaseModel):
         for candidate in candidates:
             if not candidate.startswith(f"{source}."):
                 continue
+            attribute = self.address.rsplit(".", 1)[1]
+            dtype = arg_to_datatype(target)
+            if not isinstance(dtype, StructType):
+                continue
+            output_type = dtype.field_types.get(attribute, DataType.UNKNOWN)
             return Function(
                 arguments=[target, self.address.rsplit(".", 1)[1]],
                 operator=FunctionType.ATTR_ACCESS,
                 arg_count=2,
-                output_datatype=arg_to_datatype(target),
+                output_datatype=output_type,
                 output_purpose=Purpose.PROPERTY,
             )
         return self
@@ -654,6 +659,12 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
     def validate_comparison(self):
         left_type = arg_to_datatype(self.left)
         right_type = arg_to_datatype(self.right)
+        left_name = (
+            left_type.name if isinstance(left_type, DataType) else str(left_type)
+        )
+        right_name = (
+            right_type.name if isinstance(right_type, DataType) else str(right_type)
+        )
         if self.operator in (ComparisonOperator.IS, ComparisonOperator.IS_NOT):
             if self.right != MagicConstants.NULL and DataType.BOOL != right_type:
                 raise SyntaxError(
@@ -671,12 +682,12 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                 left_type, right_type
             ):
                 raise SyntaxError(
-                    f"Cannot compare {left_type.name} and {right_type.name} with operator {self.operator} in {str(self)}"
+                    f"Cannot compare {left_name} and {right_name} with operator {self.operator} in {str(self)}"
                 )
         else:
             if not is_compatible_datatype(left_type, right_type):
                 raise SyntaxError(
-                    f"Cannot compare {left_type.name} ({self.left}) and {right_type.name} ({self.right}) of different types with operator {self.operator.value} in {str(self)}"
+                    f"Cannot compare {left_name} ({self.left}) and {right_name} ({self.right}) of different types with operator {self.operator.value} in {str(self)}"
                 )
 
         return self
@@ -1637,6 +1648,9 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     ] = None
     arguments: Sequence[FuncArgs]
 
+    class Config:
+        frozen = True
+
     def __repr__(self):
         return f'{self.operator.value}({",".join([str(a) for a in self.arguments])})'
 
@@ -1647,6 +1661,16 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     def datatype(self):
         return self.output_datatype
 
+    @field_validator("output_datatype")
+    @classmethod
+    def parse_output_datatype(cls, v, info: ValidationInfo):
+        values = info.data
+        if values.get("operator") == FunctionType.ATTR_ACCESS:
+            print(v)
+            if isinstance(v, StructType):
+                raise SyntaxError
+        return v
+
     @field_validator("arguments", mode="before")
     @classmethod
     def parse_arguments(cls, v, info: ValidationInfo):
@@ -1745,8 +1769,16 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         ]
         if self.output_datatype == DataType.UNKNOWN:
             new_output = merge_datatypes([arg_to_datatype(x) for x in nargs])
+
+            if self.operator == FunctionType.ATTR_ACCESS:
+                if isinstance(new_output, StructType):
+                    new_output = new_output.field_types[str(nargs[1])]
         else:
             new_output = self.output_datatype
+        # this is not ideal - see hacky logic for datatypes above
+        # we need to figure out how to patch properly
+        # should use function factory, but does not have environment access
+        # probably move all datatype resolution to build?
         return Function.model_construct(
             operator=self.operator,
             arguments=nargs,
@@ -2444,6 +2476,7 @@ FuncArgs = (
     | CaseElse
     | WindowItem
     | FilterItem
+    | bool
     | int
     | float
     | DatePart

trilogy/core/models/core.py

@@ -244,6 +244,19 @@ class StructType(BaseModel):
     def value(self):
         return self.data_type.value
 
+    @property
+    def field_types(self) -> Dict[str, CONCRETE_TYPES]:
+        out: Dict[str, CONCRETE_TYPES] = {}
+        keys = list(self.fields_map.keys())
+        for idx, field in enumerate(self.fields):
+            if isinstance(field, StructComponent):
+                out[field.name] = arg_to_datatype(field.type)
+            elif isinstance(field, DataTyped):
+                out[keys[idx]] = field.output_datatype
+            else:
+                out[keys[idx]] = field
+        return out
+
     def __hash__(self):
         return hash(str(self))
 
@@ -251,9 +264,10 @@ class StructType(BaseModel):
 class ListWrapper(Generic[VT], UserList):
     """Used to distinguish parsed list objects from other lists"""
 
-    def __init__(self, *args, type: DataType, **kwargs):
+    def __init__(self, *args, type: DataType, nullable: bool = False, **kwargs):
         super().__init__(*args, **kwargs)
         self.type = type
+        self.nullable = nullable
 
     @classmethod
     def __get_pydantic_core_schema__(
@@ -302,10 +316,11 @@ class MapWrapper(Generic[KT, VT], UserDict):
 class TupleWrapper(Generic[VT], tuple):
     """Used to distinguish parsed tuple objects from other tuples"""
 
-    def __init__(self, val, type: DataType, **kwargs):
+    def __init__(self, val, type: DataType, nullable: bool = False, **kwargs):
         super().__init__()
         self.type = type
         self.val = val
+        self.nullable = nullable
 
     def __getnewargs__(self):
         return (self.val, self.type)
@@ -331,15 +346,19 @@ class TupleWrapper(Generic[VT], tuple):
 
 
 def list_to_wrapper(args):
-    types = [arg_to_datatype(arg) for arg in args]
-    assert len(set(types)) == 1
-    return ListWrapper(args, type=types[0])
+    rtypes = [arg_to_datatype(arg) for arg in args]
+    types = [arg for arg in rtypes if arg != DataType.NULL]
+    if not len(set(types)) == 1:
+        raise SyntaxError(f"Cannot create a list with this set of types: {set(types)}")
+    return ListWrapper(args, type=types[0], nullable=DataType.NULL in rtypes)
 
 
 def tuple_to_wrapper(args):
-    types = [arg_to_datatype(arg) for arg in args]
-    assert len(set(types)) == 1
-    return TupleWrapper(args, type=types[0])
+    rtypes = [arg_to_datatype(arg) for arg in args]
+    types = [arg for arg in rtypes if arg != DataType.NULL]
+    if not len(set(types)) == 1:
+        raise SyntaxError(f"Cannot create a tuple with this set of types: {set(types)}")
+    return TupleWrapper(args, type=types[0], nullable=DataType.NULL in rtypes)
 
 
 def dict_to_map_wrapper(arg):

trilogy/core/processing/node_generators/filter_node.py

@@ -77,11 +77,17 @@ def build_parent_concepts(
         True if (conditions and conditions == filter_where) else False
     )
 
+    exact_partial_matches = True
     for x in local_optional:
         if isinstance(x.lineage, FILTER_TYPES):
-            if concept.lineage.where == filter_where:
+            if set([x.address for x in x.lineage.where.concept_arguments]) == set(
+                [x.address for x in filter_where.concept_arguments]
+            ):
+                exact_partial_matches = (
+                    exact_partial_matches and x.lineage.where == filter_where
+                )
                 logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} fetching parents for peer {x} with same filter conditions"
+                    f"{padding(depth)}{LOGGER_PREFIX} fetching parents for peer {x.address} (of {concept.address})"
                 )
 
                 for arg in x.lineage.content_concept_arguments:
@@ -100,7 +106,7 @@ def build_parent_concepts(
         if x.address in same_filter_optional:
             continue
         extra_row_level_optional.append(x)
-    is_optimized_pushdown = pushdown_filter_to_parent(
+    is_optimized_pushdown = exact_partial_matches and pushdown_filter_to_parent(
         local_optional, conditions, filter_where, same_filter_optional, depth
     )
     if not is_optimized_pushdown:

trilogy/dialect/base.py

@@ -174,7 +174,7 @@ FUNCTION_MAP = {
     FunctionType.CAST: lambda x: f"cast({x[0]} as {x[1]})",
     FunctionType.CASE: lambda x: render_case(x),
     FunctionType.SPLIT: lambda x: f"split({x[0]}, {x[1]})",
-    FunctionType.IS_NULL: lambda x: f"isnull({x[0]})",
+    FunctionType.IS_NULL: lambda x: f"{x[0]} is null",
     FunctionType.BOOL: lambda x: f"CASE WHEN {x[0]} THEN TRUE ELSE FALSE END",
     FunctionType.PARENTHETICAL: lambda x: f"({x[0]})",
     # Complex

trilogy/dialect/bigquery.py

@@ -24,7 +24,7 @@ FUNCTION_MAP = {
     FunctionType.LIKE: lambda x: (
         f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
     ),
-    FunctionType.IS_NULL: lambda x: f"CASE WHEN {x[0]} IS NULL THEN True ELSE False END",
+    FunctionType.IS_NULL: lambda x: f"{x[0]} IS NULL",
     FunctionType.MINUTE: lambda x: f"EXTRACT(MINUTE from {x[0]})",
     FunctionType.SECOND: lambda x: f"EXTRACT(SECOND from {x[0]})",
     FunctionType.HOUR: lambda x: f"EXTRACT(HOUR from {x[0]})",

trilogy/executor.py

@@ -6,7 +6,7 @@ from typing import Any, Generator, List, Optional, Protocol
 from sqlalchemy import text
 from sqlalchemy.engine import CursorResult
 
-from trilogy.constants import Rendering, logger
+from trilogy.constants import MagicConstants, Rendering, logger
 from trilogy.core.enums import FunctionType, Granularity, IOType
 from trilogy.core.models.author import Concept, ConceptRef, Function
 from trilogy.core.models.build import BuildFunction
@@ -388,6 +388,11 @@ class Executor(object):
             if persist and isinstance(x, ProcessedQueryPersist):
                 self.environment.add_datasource(x.datasource)
 
+    def _atom_to_value(self, val: Any) -> Any:
+        if val == MagicConstants.NULL:
+            return None
+        return val
+
     def _concept_to_value(
         self,
         concept: Concept,
@@ -402,12 +407,15 @@ class Executor(object):
         ):
             rval = concept.lineage.arguments[0]
             if isinstance(rval, ListWrapper):
-                return [x for x in rval]
+                return [self._atom_to_value(x) for x in rval]
             if isinstance(rval, MapWrapper):
                 # duckdb expects maps in this format as variables
                 if self.dialect == Dialects.DUCK_DB:
-                    return {"key": [x for x in rval], "value": [rval[x] for x in rval]}
-                return {k: v for k, v in rval.items()}
+                    return {
+                        "key": [self._atom_to_value(x) for x in rval],
+                        "value": [self._atom_to_value(rval[x]) for x in rval],
+                    }
+                return {k: self._atom_to_value(v) for k, v in rval.items()}
             # if isinstance(rval, ConceptRef):
             #     return self._concept_to_value(self.environment.concepts[rval.address], local_concepts=local_concepts)
             return rval

trilogy/parsing/parse_engine.py

@@ -701,6 +701,7 @@ class ParseToObjects(Transformer):
                 environment=self.environment,
                 metadata=metadata,
             )
+
             # let constant purposes exist to support round-tripping
             # as a build concept may end up with a constant based on constant inlining happening recursively
             if purpose == Purpose.KEY and concept.purpose != Purpose.KEY:
@@ -922,7 +923,6 @@ class ParseToObjects(Transformer):
             name=output,
             metadata=metadata,
         )
-
         return ConceptTransform(function=transformation, output=concept)
 
     @v_args(meta=True)
@@ -2040,6 +2040,15 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def fnot(self, meta, args):
+        if arg_to_datatype(args[0]) == DataType.BOOL:
+            return Comparison(
+                left=self.function_factory.create_function(
+                    [args[0], False], FunctionType.COALESCE, meta
+                ),
+                operator=ComparisonOperator.EQ,
+                right=False,
+                meta=meta,
+            )
         return self.function_factory.create_function(args, FunctionType.IS_NULL, meta)
 
     @v_args(meta=True)