pytrilogy 0.0.3.99__tar.gz → 0.0.3.101__tar.gz

{pytrilogy-0.0.3.99/pytrilogy.egg-info → pytrilogy-0.0.3.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.99
+Version: 0.0.3.101
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -123,15 +123,12 @@ Versus SQL, Trilogy aims to:
 **Improve:**
 - Simplicity
 - Refactoring/maintainability
-- Reusability
+- Reusability/composability
+- Expressivness
 
 **Maintain:**
 - Acceptable performance
 
-**Remove:**
-- Lower-level procedural features
-- Transactional optimizations/non-analytics features
-
 ## Backend Support
 
 | Backend | Status | Notes |
@@ -161,6 +158,7 @@ property sentence_id.word_three string::word; # a description to it
 # comments in other places are just comments
 
 # define our datasource to bind the model to data
+# for most work, you can import something already defined
 # testing using query fixtures is a common pattern
 datasource word_one(
     sentence: sentence_id,
@@ -323,7 +321,7 @@ from pytrilogy import Executor, Dialect
 
 ### Authoring Imports
 
-Are also stable, and should be used for cases which programatically generate Trilogy statements without a base text format 
+Are also stable, and should be used for cases which programatically generate Trilogy statements without text inputs
 or need to process/transform parsed code in more complicated ways.
 
 ```python
@@ -391,6 +389,16 @@ datasource <name>(
 )
 grain(<concept>, <concept>)
 address <table>;
+
+datasource orders(
+    order_id,
+    order_date,
+    total_rev: point_of_sale_rev,
+    customomer_id: customer.id
+)
+grain orders
+address orders;
+
 ```
 
 ### Queries

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/README.md

@@ -85,15 +85,12 @@ Versus SQL, Trilogy aims to:
 **Improve:**
 - Simplicity
 - Refactoring/maintainability
-- Reusability
+- Reusability/composability
+- Expressivness
 
 **Maintain:**
 - Acceptable performance
 
-**Remove:**
-- Lower-level procedural features
-- Transactional optimizations/non-analytics features
-
 ## Backend Support
 
 | Backend | Status | Notes |
@@ -123,6 +120,7 @@ property sentence_id.word_three string::word; # a description to it
 # comments in other places are just comments
 
 # define our datasource to bind the model to data
+# for most work, you can import something already defined
 # testing using query fixtures is a common pattern
 datasource word_one(
     sentence: sentence_id,
@@ -285,7 +283,7 @@ from pytrilogy import Executor, Dialect
 
 ### Authoring Imports
 
-Are also stable, and should be used for cases which programatically generate Trilogy statements without a base text format 
+Are also stable, and should be used for cases which programatically generate Trilogy statements without text inputs
 or need to process/transform parsed code in more complicated ways.
 
 ```python
@@ -353,6 +351,16 @@ datasource <name>(
 )
 grain(<concept>, <concept>)
 address <table>;
+
+datasource orders(
+    order_id,
+    order_date,
+    total_rev: point_of_sale_rev,
+    customomer_id: customer.id
+)
+grain orders
+address orders;
+
 ```
 
 ### Queries

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.99
+Version: 0.0.3.101
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -123,15 +123,12 @@ Versus SQL, Trilogy aims to:
 **Improve:**
 - Simplicity
 - Refactoring/maintainability
-- Reusability
+- Reusability/composability
+- Expressivness
 
 **Maintain:**
 - Acceptable performance
 
-**Remove:**
-- Lower-level procedural features
-- Transactional optimizations/non-analytics features
-
 ## Backend Support
 
 | Backend | Status | Notes |
@@ -161,6 +158,7 @@ property sentence_id.word_three string::word; # a description to it
 # comments in other places are just comments
 
 # define our datasource to bind the model to data
+# for most work, you can import something already defined
 # testing using query fixtures is a common pattern
 datasource word_one(
     sentence: sentence_id,
@@ -323,7 +321,7 @@ from pytrilogy import Executor, Dialect
 
 ### Authoring Imports
 
-Are also stable, and should be used for cases which programatically generate Trilogy statements without a base text format 
+Are also stable, and should be used for cases which programatically generate Trilogy statements without text inputs
 or need to process/transform parsed code in more complicated ways.
 
 ```python
@@ -391,6 +389,16 @@ datasource <name>(
 )
 grain(<concept>, <concept>)
 address <table>;
+
+datasource orders(
+    order_id,
+    order_date,
+    total_rev: point_of_sale_rev,
+    customomer_id: customer.id
+)
+grain orders
+address orders;
+
 ```
 
 ### Queries

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/pytrilogy.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ tests/test_statements.py
 tests/test_typing.py
 tests/test_undefined_concept.py
 tests/test_user_functions.py
+tests/test_validators.py
 tests/test_where_clause.py
 trilogy/__init__.py
 trilogy/constants.py
@@ -71,7 +72,6 @@ trilogy/core/optimizations/inline_datasource.py
 trilogy/core/optimizations/predicate_pushdown.py
 trilogy/core/processing/__init__.py
 trilogy/core/processing/concept_strategies_v3.py
-trilogy/core/processing/discovery_loop.py
 trilogy/core/processing/discovery_node_factory.py
 trilogy/core/processing/discovery_utility.py
 trilogy/core/processing/discovery_validation.py

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/tests/test_discovery_nodes.py

@@ -2,11 +2,11 @@ from trilogy.core.constants import ALL_ROWS_CONCEPT, INTERNAL_NAMESPACE
 from trilogy.core.models.build import BuildGrain
 from trilogy.core.models.environment import Environment
 from trilogy.core.processing.concept_strategies_v3 import (
-    GroupNode,
     History,
     search_concepts,
 )
 from trilogy.core.processing.node_generators import gen_group_node
+from trilogy.core.processing.nodes import GroupNode
 
 
 def test_group_node(test_environment, test_environment_graph):
@@ -53,7 +53,7 @@ def test_group_node_property(test_environment: Environment, test_environment_gra
     }
     assert input_concept_names == {
         "category_name_length",
-        "category_name",
+        # "category_name",
         "category_id",
     }
     final = group_node.resolve()
@@ -85,7 +85,7 @@ def test_group_node_property_all(test_environment: Environment, test_environment
     }
     assert input_concept_names == {
         "category_name_length",
-        "category_name",
+        # "category_name",
         "category_id",
     }
     final = group_node.resolve()

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/tests/test_parsing.py

@@ -552,7 +552,7 @@ const labels <- '';
 
 def test_struct_attr_access():
     text = """
-const labels <- struct(a->1, b->2, c->3);
+const labels <- struct(1->a, 2->b, 3->c);
 
 
 select

pytrilogy-0.0.3.101/tests/test_validators.py

@@ -0,0 +1,209 @@
+from datetime import date, datetime
+from decimal import Decimal
+
+from trilogy.core.models.core import (
+    ArrayType,
+    DataType,
+    MapType,
+    NumericType,
+    StructType,
+    TraitDataType,
+)
+from trilogy.core.validation.datasource import type_check
+
+
+def test_type_check():
+    # Basic string tests
+    assert type_check("hello", DataType.STRING)
+    assert not type_check(123, DataType.STRING)
+    assert type_check("", DataType.STRING)  # empty string
+
+    # Integer tests
+    assert type_check(123, DataType.INTEGER)
+    assert type_check(0, DataType.INTEGER)
+    assert type_check(-123, DataType.INTEGER)
+    assert not type_check("123", DataType.INTEGER)
+    assert not type_check(123.0, DataType.INTEGER)  # float should not match int
+
+    # BIGINT tests (same as INTEGER in implementation)
+    assert type_check(123, DataType.BIGINT)
+    assert type_check(2**63 - 1, DataType.BIGINT)  # large integer
+    assert not type_check("123", DataType.BIGINT)
+    assert not type_check(123.0, DataType.BIGINT)
+
+    # Float tests
+    assert type_check(123.45, DataType.FLOAT)
+    assert type_check(123, DataType.FLOAT)  # int should match float
+    assert type_check(0.0, DataType.FLOAT)
+    assert type_check(-123.45, DataType.FLOAT)
+    assert not type_check("123.45", DataType.FLOAT)
+
+    # Decimal support in float
+    decimal_val = Decimal("123.45")
+    assert type_check(decimal_val, DataType.FLOAT)
+
+    # NumericType tests
+    numeric_type = NumericType()  # Assuming NumericType can be instantiated
+    assert type_check(123.45, numeric_type)
+    assert type_check(123, numeric_type)
+    assert type_check(decimal_val, numeric_type)
+    assert not type_check("123", numeric_type)
+
+    # NUMBER and NUMERIC tests (both handle int, float, Decimal)
+    assert type_check(123, DataType.NUMBER)
+    assert type_check(123.45, DataType.NUMBER)
+    assert type_check(decimal_val, DataType.NUMBER)
+    assert not type_check("123", DataType.NUMBER)
+
+    assert type_check(123, DataType.NUMERIC)
+    assert type_check(123.45, DataType.NUMERIC)
+    assert type_check(decimal_val, DataType.NUMERIC)
+    assert not type_check("123", DataType.NUMERIC)
+
+    # Boolean tests
+    assert type_check(True, DataType.BOOL)
+    assert type_check(False, DataType.BOOL)
+    assert not type_check(1, DataType.BOOL)  # int should not match bool
+    assert not type_check(0, DataType.BOOL)
+    assert not type_check("true", DataType.BOOL)
+
+    # Date tests
+    test_date = date(2023, 12, 25)
+    assert type_check(test_date, DataType.DATE)
+    assert not type_check("2023-12-25", DataType.DATE)
+    assert not type_check(
+        datetime.now(), DataType.DATE
+    )  # datetime should not match date
+
+    # DateTime and Timestamp tests
+    test_datetime = datetime(2023, 12, 25, 15, 30, 45)
+    assert type_check(test_datetime, DataType.DATETIME)
+    assert type_check(test_datetime, DataType.TIMESTAMP)
+    assert not type_check("2023-12-25 15:30:45", DataType.DATETIME)
+    assert not type_check(
+        test_date, DataType.DATETIME
+    )  # date should not match datetime
+
+    # Unix seconds tests
+    assert type_check(1640995200, DataType.UNIX_SECONDS)  # int timestamp
+    assert type_check(1640995200.123, DataType.UNIX_SECONDS)  # float timestamp
+    assert not type_check("1640995200", DataType.UNIX_SECONDS)
+
+    # Date part tests
+    assert type_check("year", DataType.DATE_PART)
+    assert type_check("month", DataType.DATE_PART)
+    assert type_check("day", DataType.DATE_PART)
+    assert not type_check(2023, DataType.DATE_PART)
+
+    # Array tests
+    assert type_check([1, 2, 3], DataType.ARRAY)
+    assert type_check([], DataType.ARRAY)  # empty array
+    assert type_check(["a", "b"], DataType.ARRAY)
+    assert not type_check("not a list", DataType.ARRAY)
+    assert not type_check({"key": "value"}, DataType.ARRAY)
+
+    # ArrayType tests
+    array_type = ArrayType(type=DataType.INTEGER)
+    assert type_check([1, 2, 3], array_type)
+    assert not type_check("not a list", array_type)
+
+    # Map tests
+    assert type_check({"key": "value"}, DataType.MAP)
+    assert type_check({}, DataType.MAP)  # empty dict
+    assert type_check({"a": 1, "b": 2}, DataType.MAP)
+    assert not type_check([1, 2, 3], DataType.MAP)
+    assert not type_check("not a dict", DataType.MAP)
+
+    # MapType tests
+    map_type = MapType(key_type=DataType.STRING, value_type=DataType.STRING)
+    assert type_check({"key": "value"}, map_type)
+    assert not type_check([1, 2, 3], map_type)
+
+    # Struct tests
+    assert type_check({"field1": "value1"}, DataType.STRUCT)
+    assert type_check({}, DataType.STRUCT)
+    assert not type_check([1, 2, 3], DataType.STRUCT)
+
+    # StructType tests
+    struct_type = StructType(
+        fields=[DataType.STRING, DataType.STRING],
+        fields_map={"field1": DataType.STRING, "field2": DataType.STRING},
+    )
+    assert not type_check("not a dict", struct_type)
+
+    # NULL tests
+    assert type_check(None, DataType.NULL)
+    assert not type_check("", DataType.NULL)
+    assert not type_check(0, DataType.NULL)
+    assert not type_check(False, DataType.NULL)
+
+    # UNKNOWN tests (should accept anything)
+    assert type_check("anything", DataType.UNKNOWN)
+    assert type_check(123, DataType.UNKNOWN)
+    assert type_check(None, DataType.UNKNOWN)
+    assert type_check([1, 2, 3], DataType.UNKNOWN)
+    assert type_check({"key": "value"}, DataType.UNKNOWN)
+
+    # Nullable tests
+    assert type_check(None, DataType.STRING)  # nullable by default
+    assert type_check(None, DataType.INTEGER)
+    assert type_check(None, DataType.FLOAT)
+    assert type_check(None, DataType.BOOL)
+
+    # Non-nullable tests
+    assert not type_check(None, DataType.STRING, nullable=False)
+    assert not type_check(None, DataType.INTEGER, nullable=False)
+    assert not type_check(None, DataType.FLOAT, nullable=False)
+    assert not type_check(None, DataType.BOOL, nullable=False)
+
+    # TraitDataType tests (recursive handling)
+    # Assuming TraitDataType wraps another DataType
+    trait_string_type = TraitDataType(type=DataType.STRING, traits=[])
+    assert type_check("hello", trait_string_type)
+    assert not type_check(123, trait_string_type)
+    assert type_check(None, trait_string_type)  # nullable by default
+    assert not type_check(None, trait_string_type, nullable=False)
+
+    # Nested TraitDataType
+    nested_trait_type = TraitDataType(type=DataType.STRING, traits=[])
+    assert type_check("hello", nested_trait_type)
+    assert not type_check(123, nested_trait_type)
+
+    # Edge cases and invalid types
+    # Test with unsupported/custom types should return False
+    class CustomType:
+        pass
+
+    custom_obj = CustomType()
+    # These should all return False as they don't match any known type
+    assert not type_check(custom_obj, DataType.STRING)
+    assert not type_check(custom_obj, DataType.INTEGER)
+    assert not type_check(custom_obj, DataType.ARRAY)
+
+
+def test_type_check_edge_cases():
+    """Additional edge case tests"""
+
+    # Test very large numbers
+    large_int = 2**100
+    assert type_check(large_int, DataType.INTEGER)
+    assert type_check(large_int, DataType.BIGINT)
+    assert type_check(large_int, DataType.FLOAT)  # int should match float
+
+    # Test special float values
+    assert type_check(float("inf"), DataType.FLOAT)
+    assert type_check(float("-inf"), DataType.FLOAT)
+    # Note: NaN might need special handling depending on requirements
+    # assert type_check(float('nan'), DataType.FLOAT)
+
+    # Test empty collections
+    assert type_check([], DataType.ARRAY)
+    assert type_check({}, DataType.MAP)
+    assert type_check({}, DataType.STRUCT)
+
+    # Test nested collections
+    nested_list = [[1, 2], [3, 4]]
+    nested_dict = {"outer": {"inner": "value"}}
+    assert type_check(nested_list, DataType.ARRAY)
+    assert type_check(nested_dict, DataType.MAP)
+    assert type_check(nested_dict, DataType.STRUCT)

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

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/trilogy/constants.py

@@ -40,6 +40,7 @@ class Comments:
     joins: bool = True
     nullable: bool = True
     partial: bool = True
+    source_map: bool = False
 
 
 @dataclass

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/trilogy/core/exceptions.py

@@ -69,7 +69,7 @@ class DatasourceColumnBindingData:
     actual_modifiers: List[Modifier]
 
     def format_failure(self):
-        return f"Concept {self.address} value '{self.value}' with type {self.value_modifiers} does not conform to expected type {str(self.actual_type)} with modifiers {self.actual_modifiers}"
+        return f"Concept {self.address} value '{self.value}' with type {self.value_type} and {self.value_modifiers} does not conform to expected type {str(self.actual_type)} with modifiers {self.actual_modifiers}"
 
     def is_modifier_issue(self) -> bool:
         return len(self.value_modifiers) > 0 and any(

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/trilogy/core/functions.py

@@ -18,6 +18,7 @@ from trilogy.core.models.author import (
     AggregateWrapper,
     Concept,
     ConceptRef,
+    Conditional,
     Function,
     Parenthetical,
     UndefinedConcept,
@@ -129,8 +130,8 @@ def validate_case_output(
 def create_struct_output(
     args: list[Any],
 ) -> StructType:
-    zipped = dict(zip(args[::2], args[1::2]))
-    types = [arg_to_datatype(x) for x in args[1::2]]
+    zipped = dict(zip(args[1::2], args[::2]))
+    types = [arg_to_datatype(x) for x in args[::2]]
     return StructType(fields=types, fields_map=zipped)
 
 
@@ -997,6 +998,8 @@ def argument_to_purpose(arg) -> Purpose:
         return argument_to_purpose(arg.content)
     elif isinstance(arg, WindowItem):
         return Purpose.PROPERTY
+    elif isinstance(arg, Conditional):
+        return Purpose.PROPERTY
     elif isinstance(arg, Concept):
         base = arg.purpose
         if (

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/trilogy/core/models/core.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from abc import ABC
 from collections import UserDict, UserList
 from datetime import date, datetime
+from decimal import Decimal
 from enum import Enum
 from typing import (
     Any,
@@ -448,6 +449,8 @@ def arg_to_datatype(arg) -> CONCRETE_TYPES:
         return DataType.STRING
     elif isinstance(arg, float):
         return DataType.FLOAT
+    elif isinstance(arg, Decimal):
+        return DataType.NUMERIC
     elif isinstance(arg, DataType):
         return arg
     elif isinstance(arg, NumericType):

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/trilogy/core/models/execute.py

@@ -118,19 +118,20 @@ class CTE(BaseModel):
         base += f" Source: {self.source.source_type}."
         if self.parent_ctes:
             base += f" References: {', '.join([x.name for x in self.parent_ctes])}."
-        if self.joins:
+        if self.joins and CONFIG.comments.joins:
             base += f"\n-- Joins: {', '.join([str(x) for x in self.joins])}."
-        if self.partial_concepts:
+        if self.partial_concepts and CONFIG.comments.partial:
             base += (
                 f"\n-- Partials: {', '.join([str(x) for x in self.partial_concepts])}."
             )
-        base += f"\n-- Source Map: {self.source_map}."
+        if CONFIG.comments.source_map:
+            base += f"\n-- Source Map: {self.source_map}."
         base += f"\n-- Output: {', '.join([str(x) for x in self.output_columns])}."
         if self.source.input_concepts:
             base += f"\n-- Inputs: {', '.join([str(x) for x in self.source.input_concepts])}."
         if self.hidden_concepts:
             base += f"\n-- Hidden: {', '.join([str(x) for x in self.hidden_concepts])}."
-        if self.nullable_concepts:
+        if self.nullable_concepts and CONFIG.comments.nullable:
             base += (
                 f"\n-- Nullable: {', '.join([str(x) for x in self.nullable_concepts])}."
             )
@@ -368,6 +369,7 @@ class CTE(BaseModel):
     @property
     def group_concepts(self) -> List[BuildConcept]:
         def check_is_not_in_group(c: BuildConcept):
+
             if len(self.source_map.get(c.address, [])) > 0:
                 return False
             if c.derivation == Derivation.ROWSET:
@@ -381,8 +383,6 @@ class CTE(BaseModel):
                 and c.lineage.operator in FunctionClass.AGGREGATE_FUNCTIONS.value
             ):
                 return True
-            if c.purpose == Purpose.METRIC:
-                return True
 
             if c.derivation == Derivation.BASIC and c.lineage:
                 if all([check_is_not_in_group(x) for x in c.lineage.concept_arguments]):
@@ -392,6 +392,10 @@ class CTE(BaseModel):
                     and c.lineage.operator == FunctionType.GROUP
                 ):
                     return check_is_not_in_group(c.lineage.concept_arguments[0])
+                return False
+            if c.purpose == Purpose.METRIC:
+                return True
+
             return False
 
         return (
@@ -707,6 +711,8 @@ class QueryDatasource(BaseModel):
             f" {[c.address for c in self.output_concepts]} concepts and"
             f" {other.name} with {[c.address for c in other.output_concepts]} concepts"
         )
+        logger.info(self.source_map)
+        logger.info(other.source_map)
 
         merged_datasources: dict[str, Union[BuildDatasource, "QueryDatasource"]] = {}
 
@@ -770,6 +776,7 @@ class QueryDatasource(BaseModel):
         logger.debug(
             f"[Query Datasource] merged with {[c.address for c in qds.output_concepts]} concepts"
         )
+        logger.debug(qds.source_map)
         return qds
 
     @property
@@ -777,7 +784,7 @@ class QueryDatasource(BaseModel):
         filters = abs(hash(str(self.condition))) if self.condition else ""
         grain = "_".join([str(c).replace(".", "_") for c in self.grain.components])
         group = ""
-        if self.source_type == SourceType.GROUP:
+        if self.group_required:
             keys = [
                 x.address for x in self.output_concepts if x.purpose != Purpose.METRIC
             ]

{pytrilogy-0.0.3.99 → pytrilogy-0.0.3.101}/trilogy/core/processing/concept_strategies_v3.py

@@ -19,13 +19,13 @@ from trilogy.core.processing.discovery_utility import (
     LOGGER_PREFIX,
     depth_to_prefix,
     get_priority_concept,
+    group_if_required,
 )
 from trilogy.core.processing.discovery_validation import (
     ValidationResult,
     validate_stack,
 )
 from trilogy.core.processing.nodes import (
-    GroupNode,
     History,
     MergeNode,
     StrategyNode,
@@ -218,6 +218,7 @@ def initialize_loop_context(
                 f"{depth_to_prefix(depth)}{LOGGER_PREFIX} derived condition row inputs {[x.address for x in required_filters]} present in mandatory list, forcing condition evaluation at this level. "
             )
             mandatory_list = completion_mandatory
+            all_mandatory = set(c.address for c in completion_mandatory)
             must_evaluate_condition_on_this_level_not_push_down = True
         else:
             logger.info(
@@ -263,7 +264,7 @@ def evaluate_loop_conditions(
             ]
         ) and not any(
             [
-                x.derivation not in ROOT_DERIVATIONS
+                x.derivation not in ROOT_DERIVATIONS + [Derivation.BASIC]
                 for x in context.mandatory_list
                 if x.address not in context.conditions.row_arguments
             ]
@@ -282,7 +283,7 @@ def evaluate_loop_conditions(
     # to ensure filtering happens before something like a SUM
     if (
         context.conditions
-        and priority_concept.derivation not in ROOT_DERIVATIONS
+        and priority_concept.derivation not in ROOT_DERIVATIONS + [Derivation.BASIC]
         and priority_concept.address not in context.conditions.row_arguments
     ):
         logger.info(
@@ -419,26 +420,9 @@ def generate_loop_completion(context: LoopContext, virtual: set[str]) -> Strateg
         logger.info(
             f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Conditions {context.conditions} were injected, checking if we need a group to restore grain"
         )
-
-        result = GroupNode.check_if_required(
-            downstream_concepts=output.usable_outputs,
-            parents=[output.resolve()],
-            environment=context.environment,
-            depth=context.depth,
+        return group_if_required(
+            output, context.original_mandatory, context.environment
         )
-        if result.required:
-            logger.info(
-                f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Adding group node with outputs {[x.address for x in context.original_mandatory]}"
-            )
-            return GroupNode(
-                output_concepts=context.original_mandatory,
-                input_concepts=output.usable_outputs,
-                environment=context.environment,
-                parents=[output],
-                partial_concepts=output.partial_concepts,
-                preexisting_conditions=context.conditions.conditional,
-                depth=context.depth,
-            )
     return output
 
 
@@ -604,18 +588,4 @@ def source_query_concepts(
     logger.info(
         f"{depth_to_prefix(0)}{LOGGER_PREFIX} final concepts are {[x.address for x in final]}"
     )
-    if GroupNode.check_if_required(
-        downstream_concepts=final,
-        parents=[root.resolve()],
-        environment=environment,
-    ).required:
-        candidate: StrategyNode = GroupNode(
-            output_concepts=final,
-            input_concepts=final,
-            environment=environment,
-            parents=[root],
-            partial_concepts=root.partial_concepts,
-        )
-    else:
-        candidate = root
-    return candidate
+    return group_if_required(root, output_concepts, environment)