pytrilogy 0.0.3.48__tar.gz → 0.0.3.51__tar.gz

{pytrilogy-0.0.3.48/pytrilogy.egg-info → pytrilogy-0.0.3.51}/PKG-INFO

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

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/tests/test_functions.py

@@ -214,6 +214,8 @@ def test_math_functions(test_environment):
     property order_id.order_nested <- revenue * 2/2;
     property order_id.rounded <- round(revenue + 2.01,2);
     property order_id.rounded_default <- round(revenue + 2.01);
+    property order_id.floor <- floor(revenue + 2.01);
+    property order_id.ceil <- ceil(revenue + 2.01);
     constant random <- random(1);
     select
         order_id,
@@ -224,6 +226,8 @@ def test_math_functions(test_environment):
         order_add,
         rounded,
         rounded_default,
+        floor,
+        ceil,
         random,
     ;"""
     env, parsed = parse(declarations, environment=test_environment)

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/tests/test_parse_engine.py

@@ -2,7 +2,12 @@ from pytest import raises
 
 from trilogy.core.exceptions import UndefinedConceptException
 from trilogy.core.models.environment import Environment
-from trilogy.parsing.parse_engine import PARSER, ParseToObjects, unpack_visit_error
+from trilogy.parsing.parse_engine import (
+    PARSER,
+    InvalidSyntaxException,
+    ParseToObjects,
+    unpack_visit_error,
+)
 
 TEXT = """
 const a <- 1;
@@ -29,3 +34,20 @@ def test_parser():
         with raises(UndefinedConceptException):
             unpack_visit_error(e)
     assert failed
+
+
+TEXT2 = """
+const a <- 1;
+
+select
+    a,
+FROM a
+;
+"""
+
+
+def test_from_error():
+    env = Environment()
+
+    with raises(InvalidSyntaxException):
+        env.parse(TEXT2)

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/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.48"
+__version__ = "0.0.3.51"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/enums.py

@@ -131,6 +131,7 @@ class FunctionType(Enum):
     CONSTANT = "constant"
     COALESCE = "coalesce"
     IS_NULL = "isnull"
+    NULLIF = "nullif"
     BOOL = "bool"
 
     # COMPLEX
@@ -156,6 +157,8 @@ class FunctionType(Enum):
     ABS = "abs"
     SQRT = "sqrt"
     RANDOM = "random"
+    FLOOR = "floor"
+    CEIL = "ceil"
 
     # Aggregates
     ## group is not a real aggregate - it just means group by this + some other set of fields

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/functions.py

@@ -279,6 +279,12 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_purpose=Purpose.PROPERTY,
         arg_count=1,
     ),
+    FunctionType.NULLIF: FunctionConfig(
+        valid_inputs={*DataType},
+        output_purpose=Purpose.PROPERTY,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
+        arg_count=2,
+    ),
     FunctionType.COALESCE: FunctionConfig(
         valid_inputs={*DataType},
         output_purpose=Purpose.PROPERTY,
@@ -637,6 +643,22 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type_function=lambda args: get_output_type_at_index(args, 0),
         arg_count=2,
     ),
+    FunctionType.FLOOR: FunctionConfig(
+        valid_inputs=[
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.INTEGER,
+        arg_count=1,
+    ),
+    FunctionType.CEIL: FunctionConfig(
+        valid_inputs=[
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.INTEGER,
+        arg_count=1,
+    ),
     FunctionType.CUSTOM: FunctionConfig(
         output_purpose=Purpose.PROPERTY,
         arg_count=InfiniteFunctionArgs,

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/models/author.py

@@ -1945,11 +1945,15 @@ class FilterItem(DataTyped, Namespaced, ConceptArgs, BaseModel):
 
     @property
     def output_datatype(self):
-        return self.content.datatype
+        return arg_to_datatype(self.content)
 
     @property
     def concept_arguments(self):
-        return [self.content] + self.where.concept_arguments
+        if isinstance(self.content, ConceptRef):
+            return [self.content] + self.where.concept_arguments
+        elif isinstance(self.content, ConceptArgs):
+            return self.content.concept_arguments + self.where.concept_arguments
+        return self.where.concept_arguments
 
 
 class RowsetLineage(Namespaced, Mergeable, BaseModel):

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/models/build.py

@@ -1173,7 +1173,7 @@ class BuildAggregateWrapper(BuildConceptArgs, DataTyped, BaseModel):
 
 
 class BuildFilterItem(BuildConceptArgs, BaseModel):
-    content: BuildConcept
+    content: "BuildExpr"
     where: BuildWhereClause
 
     def __str__(self):
@@ -1181,15 +1181,27 @@ class BuildFilterItem(BuildConceptArgs, BaseModel):
 
     @property
     def output_datatype(self):
-        return self.content.datatype
+        return arg_to_datatype(self.content)
 
     @property
     def output_purpose(self):
         return self.content.purpose
 
+    @property
+    def content_concept_arguments(self):
+        if isinstance(self.content, BuildConcept):
+            return [self.content]
+        elif isinstance(self.content, BuildConceptArgs):
+            return self.content.concept_arguments
+        return []
+
     @property
     def concept_arguments(self):
-        return [self.content] + self.where.concept_arguments
+        if isinstance(self.content, BuildConcept):
+            return [self.content] + self.where.concept_arguments
+        elif isinstance(self.content, BuildConceptArgs):
+            return self.content.concept_arguments + self.where.concept_arguments
+        return self.where.concept_arguments
 
 
 class BuildRowsetLineage(BuildConceptArgs, BaseModel):

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/models/execute.py

@@ -695,7 +695,7 @@ class QueryDatasource(BaseModel):
                 "can only merge two datasources if the force_group flag is the same"
             )
         logger.debug(
-            f"{LOGGER_PREFIX} merging {self.name} with"
+            f"[Query Datasource] merging {self.name} with"
             f" {[c.address for c in self.output_concepts]} concepts and"
             f" {other.name} with {[c.address for c in other.output_concepts]} concepts"
         )
@@ -759,7 +759,9 @@ class QueryDatasource(BaseModel):
             hidden_concepts=hidden,
             ordering=self.ordering,
         )
-
+        logger.debug(
+            f"[Query Datasource] merged with {[c.address for c in qds.output_concepts]} concepts"
+        )
         return qds
 
     @property

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/processing/concept_strategies_v3.py

@@ -319,7 +319,7 @@ def generate_node(
         ]
 
         logger.info(
-            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating aggregate node with {[x.address for x in agg_optional]}"
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating aggregate node with {[x for x in agg_optional]}"
         )
         return gen_group_node(
             concept,

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/processing/node_generators/common.py

@@ -67,14 +67,14 @@ def resolve_condition_parent_concepts(
 def resolve_filter_parent_concepts(
     concept: BuildConcept,
     environment: BuildEnvironment,
-) -> Tuple[BuildConcept, List[BuildConcept], List[Tuple[BuildConcept, ...]]]:
+) -> Tuple[List[BuildConcept], List[Tuple[BuildConcept, ...]]]:
     if not isinstance(concept.lineage, (BuildFilterItem,)):
         raise ValueError(
             f"Concept {concept} lineage is not filter item, is {type(concept.lineage)}"
         )
     direct_parent = concept.lineage.content
     base_existence = []
-    base_rows = [direct_parent]
+    base_rows = [direct_parent] if isinstance(direct_parent, BuildConcept) else []
     condition_rows, condition_existence = resolve_condition_parent_concepts(
         concept.lineage.where
     )
@@ -90,11 +90,10 @@ def resolve_filter_parent_concepts(
 
     if concept.lineage.where.existence_arguments:
         return (
-            concept.lineage.content,
             unique(base_rows, "address"),
             base_existence,
         )
-    return concept.lineage.content, unique(base_rows, "address"), []
+    return unique(base_rows, "address"), []
 
 
 def gen_property_enrichment_node(

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/processing/node_generators/filter_node.py

@@ -25,71 +25,140 @@ LOGGER_PREFIX = "[GEN_FILTER_NODE]"
 FILTER_TYPES = (BuildFilterItem,)
 
 
-def gen_filter_node(
-    concept: BuildConcept,
+def pushdown_filter_to_parent(
     local_optional: List[BuildConcept],
-    environment: BuildEnvironment,
-    g,
+    conditions: BuildWhereClause | None,
+    filter_where: BuildWhereClause,
+    same_filter_optional: list[BuildConcept],
     depth: int,
-    source_concepts,
-    history: History | None = None,
+) -> bool:
+    optimized_pushdown = False
+    if not is_scalar_condition(filter_where.conditional):
+        optimized_pushdown = False
+    elif not local_optional:
+        optimized_pushdown = True
+    elif conditions and conditions == filter_where:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} query conditions are the same as filter conditions, can optimize across all concepts"
+        )
+        optimized_pushdown = True
+    elif same_filter_optional == local_optional:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} all optional concepts are included in the filter, can optimize across all concepts"
+        )
+        optimized_pushdown = True
+
+    return optimized_pushdown
+
+
+def build_parent_concepts(
+    concept: BuildConcept,
+    environment: BuildEnvironment,
+    local_optional: List[BuildConcept],
     conditions: BuildWhereClause | None = None,
-) -> StrategyNode | None:
-    immediate_parent, parent_row_concepts, parent_existence_concepts = (
-        resolve_filter_parent_concepts(concept, environment)
+    depth: int = 0,
+):
+    parent_row_concepts, parent_existence_concepts = resolve_filter_parent_concepts(
+        concept, environment
     )
     if not isinstance(concept.lineage, FILTER_TYPES):
         raise SyntaxError('Filter node must have a filter type lineage"')
-    where = concept.lineage.where
+    filter_where = concept.lineage.where
 
-    optional_included: list[BuildConcept] = []
+    same_filter_optional: list[BuildConcept] = []
 
     for x in local_optional:
         if isinstance(x.lineage, FILTER_TYPES):
-            if concept.lineage.where == where:
+            if concept.lineage.where == filter_where:
                 logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} fetching {x.lineage.content.address} as optional parent from optional {x} with same filter conditions "
+                    f"{padding(depth)}{LOGGER_PREFIX} fetching parents for peer {x} with same filter conditions"
                 )
-                if x.lineage.content.address not in parent_row_concepts:
-                    parent_row_concepts.append(x.lineage.content)
-                optional_included.append(x)
+
+                for arg in x.lineage.content_concept_arguments:
+                    if arg.address not in parent_row_concepts:
+                        parent_row_concepts.append(arg)
+                same_filter_optional.append(x)
                 continue
-        if conditions and conditions == where:
-            optional_included.append(x)
+        elif conditions and conditions == filter_where:
+            same_filter_optional.append(x)
 
     # sometimes, it's okay to include other local optional above the filter
     # in case it is, prep our list
     extra_row_level_optional: list[BuildConcept] = []
+
     for x in local_optional:
-        if x.address in optional_included:
+        if x.address in same_filter_optional:
             continue
         extra_row_level_optional.append(x)
+    is_optimized_pushdown = pushdown_filter_to_parent(
+        local_optional, conditions, filter_where, same_filter_optional, depth
+    )
+    if not is_optimized_pushdown:
+        parent_row_concepts += extra_row_level_optional
+    return (
+        parent_row_concepts,
+        parent_existence_concepts,
+        same_filter_optional,
+        is_optimized_pushdown,
+    )
 
-    # this flag controls whether we materialize the filter as a where on the prior CTE
-    # or do the filtering inline as a case statement
-    optimized_pushdown = False
-    if not is_scalar_condition(where.conditional):
-        optimized_pushdown = False
-    elif not local_optional:
-        optimized_pushdown = True
-    elif conditions and conditions == where:
+
+def add_existence_sources(
+    core_parent_nodes: list[StrategyNode],
+    parent_existence_concepts: list[tuple[BuildConcept, ...]],
+    source_concepts,
+    environment,
+    g,
+    depth,
+    history,
+):
+    for existence_tuple in parent_existence_concepts:
+        if not existence_tuple:
+            continue
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} query conditions are the same as filter conditions, can optimize across all concepts"
+            f"{padding(depth)}{LOGGER_PREFIX} fetching filter node existence parents {[x.address for x in existence_tuple]}"
         )
-        optimized_pushdown = True
-    elif optional_included == local_optional:
-        logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} all optional concepts are included in the filter, can optimize across all concepts"
+        parent_existence = source_concepts(
+            mandatory_list=list(existence_tuple),
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
         )
-        optimized_pushdown = True
-    logger.info(
-        f"{padding(depth)}{LOGGER_PREFIX} filter `{concept}` condition `{concept.lineage.where}` derived from {immediate_parent.address} row parents {[x.address for x in parent_row_concepts]} and {[[y.address] for x  in parent_existence_concepts for y  in x]} existence parents"
+        if not parent_existence:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} filter existence node parents could not be found"
+            )
+            return None
+        core_parent_nodes.append(parent_existence)
+
+
+def gen_filter_node(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    environment: BuildEnvironment,
+    g,
+    depth: int,
+    source_concepts,
+    history: History | None = None,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    if not isinstance(concept.lineage, FILTER_TYPES):
+        raise SyntaxError('Filter node must have a filter type lineage"')
+    where = concept.lineage.where
+
+    (
+        parent_row_concepts,
+        parent_existence_concepts,
+        same_filter_optional,
+        optimized_pushdown,
+    ) = build_parent_concepts(
+        concept,
+        environment=environment,
+        local_optional=local_optional,
+        conditions=conditions,
+        depth=depth,
     )
-    # we'll populate this with the row parent
-    # and the existence parent(s)
-    core_parents = []
-    if not optimized_pushdown:
-        parent_row_concepts += extra_row_level_optional
 
     row_parent: StrategyNode = source_concepts(
         mandatory_list=parent_row_concepts,
@@ -100,27 +169,19 @@ def gen_filter_node(
         conditions=conditions,
     )
 
+    core_parent_nodes: list[StrategyNode] = []
     flattened_existence = [x for y in parent_existence_concepts for x in y]
     if parent_existence_concepts:
-        for existence_tuple in parent_existence_concepts:
-            if not existence_tuple:
-                continue
-            logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} fetching filter node existence parents {[x.address for x in existence_tuple]}"
-            )
-            parent_existence = source_concepts(
-                mandatory_list=list(existence_tuple),
-                environment=environment,
-                g=g,
-                depth=depth + 1,
-                history=history,
-            )
-            if not parent_existence:
-                logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} filter existence node parents could not be found"
-                )
-                return None
-            core_parents.append(parent_existence)
+        add_existence_sources(
+            core_parent_nodes,
+            parent_existence_concepts,
+            source_concepts,
+            environment,
+            g,
+            depth,
+            history,
+        )
+
     if not row_parent:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} filter node row parents {[x.address for x in parent_row_concepts]} could not be found"
@@ -129,7 +190,7 @@ def gen_filter_node(
 
     if optimized_pushdown:
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} returning optimized filter node with pushdown to parent with condition {where.conditional}"
+            f"{padding(depth)}{LOGGER_PREFIX} returning optimized filter node with pushdown to parent with condition {where.conditional} across {[concept] + same_filter_optional + row_parent.output_concepts} "
         )
         if isinstance(row_parent, SelectNode):
             logger.info(
@@ -137,7 +198,9 @@ def gen_filter_node(
             )
             parent = StrategyNode(
                 input_concepts=row_parent.output_concepts,
-                output_concepts=[concept] + row_parent.output_concepts,
+                output_concepts=[concept]
+                + same_filter_optional
+                + row_parent.output_concepts,
                 environment=row_parent.environment,
                 parents=[row_parent],
                 depth=row_parent.depth,
@@ -146,46 +209,34 @@ def gen_filter_node(
             )
         else:
             parent = row_parent
-
-        expected_output = [concept] + [
-            x
-            for x in local_optional
-            if x.address in [y for y in parent.output_concepts]
-            or x.address in [y for y in optional_included]
-        ]
-        parent.add_parents(core_parents)
+            parent.add_output_concepts([concept] + same_filter_optional)
+        parent.add_parents(core_parent_nodes)
         parent.add_condition(where.conditional)
-        parent.add_existence_concepts(flattened_existence, False).set_output_concepts(
-            expected_output, False
-        )
+        parent.add_existence_concepts(flattened_existence, False)
         parent.grain = BuildGrain.from_concepts(
-            (
-                [environment.concepts[k] for k in immediate_parent.keys]
-                if immediate_parent.keys
-                else [immediate_parent]
-            )
-            + [
-                x
-                for x in local_optional
-                if x.address in [y.address for y in parent.output_concepts]
-            ],
+            parent.output_concepts,
             environment=environment,
         )
         parent.rebuild_cache()
         filter_node = parent
     else:
-        core_parents.append(row_parent)
-
+        core_parent_nodes.append(row_parent)
+        filters = [concept] + same_filter_optional
+        parents_for_grain = [
+            x.lineage.content
+            for x in filters
+            if isinstance(x.lineage.content, BuildConcept)
+        ]
         filter_node = FilterNode(
             input_concepts=unique(
-                [immediate_parent] + parent_row_concepts + flattened_existence,
+                parent_row_concepts + flattened_existence,
                 "address",
             ),
-            output_concepts=[concept, immediate_parent] + parent_row_concepts,
+            output_concepts=[concept] + same_filter_optional + parent_row_concepts,
             environment=environment,
-            parents=core_parents,
+            parents=core_parent_nodes,
             grain=BuildGrain.from_concepts(
-                [immediate_parent] + parent_row_concepts,
+                parents_for_grain + parent_row_concepts, environment=environment
             ),
             preexisting_conditions=conditions.conditional if conditions else None,
         )
@@ -211,7 +262,8 @@ def gen_filter_node(
     )
     enrich_node: StrategyNode = source_concepts(  # this fetches the parent + join keys
         # to then connect to the rest of the query
-        mandatory_list=[immediate_parent] + parent_row_concepts + local_optional,
+        mandatory_list=parent_row_concepts
+        + [x for x in local_optional if x.address not in filter_node.output_concepts],
         environment=environment,
         g=g,
         depth=depth + 1,
@@ -227,14 +279,13 @@ def gen_filter_node(
         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,
+        input_concepts=filter_node.output_concepts + enrich_node.output_concepts,
         output_concepts=[
             concept,
         ]
         + local_optional,
         environment=environment,
         parents=[
-            # this node fetches only what we need to filter
             filter_node,
             enrich_node,
         ],

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/processing/node_generators/group_node.py

@@ -51,6 +51,7 @@ def gen_group_node(
     ):
         grain_components = [environment.concepts[c] for c in concept.grain.components]
         parent_concepts += grain_components
+        build_grain_parents = BuildGrain.from_concepts(parent_concepts)
         output_concepts += grain_components
         for possible_agg in local_optional:
 
@@ -76,9 +77,7 @@ def gen_group_node(
                     logger.info(
                         f"{padding(depth)}{LOGGER_PREFIX} found equivalent group by optional concept {possible_agg.address} for {concept.address}"
                     )
-                elif BuildGrain.from_concepts(agg_parents) == BuildGrain.from_concepts(
-                    parent_concepts
-                ):
+                elif BuildGrain.from_concepts(agg_parents) == build_grain_parents:
                     extra = [x for x in agg_parents if x.address not in parent_concepts]
                     parent_concepts += extra
                     output_concepts.append(possible_agg)
@@ -87,7 +86,7 @@ def gen_group_node(
                     )
                 else:
                     logger.info(
-                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; mismatched grain {BuildGrain.from_concepts(agg_parents)} vs {BuildGrain.from_concepts(parent_concepts)}"
+                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; mismatched parent grain {BuildGrain.from_concepts(agg_parents)} vs local parent {BuildGrain.from_concepts(parent_concepts)}"
                     )
     if parent_concepts:
         logger.info(

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/processing/nodes/base_node.py

@@ -194,15 +194,18 @@ class StrategyNode:
         if not self.parents:
             return
         non_hidden = set()
+        hidden = set()
         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)
+            for z in x.hidden_concepts:
+                hidden.add(z)
         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(
-                f"Invalid input concepts; {missing} are missing non-hidden parent nodes"
+                f"Invalid input concepts; {missing} are missing non-hidden parent nodes; have {non_hidden} and hidden {hidden}"
             )
 
     def add_parents(self, parents: list["StrategyNode"]):

{pytrilogy-0.0.3.48 → pytrilogy-0.0.3.51}/trilogy/core/statements/author.py

@@ -162,9 +162,7 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
                 output.local_concepts[x.content.address] = environment.concepts[
                     x.content.address
                 ]
-
         output.grain = output.calculate_grain(environment, output.local_concepts)
-
         output.validate_syntax(environment)
         return output