pytrilogy 0.0.3.113__tar.gz → 0.0.3.116__tar.gz

{pytrilogy-0.0.3.113/pytrilogy.egg-info → pytrilogy-0.0.3.116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.113
+Version: 0.0.3.116
 Summary: Declarative, typed query language that compiles to SQL.
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.113
+Version: 0.0.3.116
 Summary: Declarative, typed query language that compiles to SQL.
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/tests/test_functions.py

@@ -168,7 +168,7 @@ def test_date_functions(test_environment):
 
     for dialect in TEST_DIALECTS:
         engine = None
-        if isinstance(dialect, BigqueryDialect):
+        if isinstance(dialect, DuckDBDialect):
             engine = Dialects.DUCK_DB.default_executor(environment=test_environment)
         dialect.compile_statement(process_query(test_environment, select))
         if engine:
@@ -308,16 +308,43 @@ def test_string_functions(test_environment):
     property regex_replace <- regexp_replace(category_name, 'a', 'b');
 
     select
+        category_id,
         test_name,
         upper_name,
         lower_name,
         substring_name,
         strpos_name,
+        like_name,
+        like_alt,
+        regex_contains,
+        regex_substring,
+        regex_replace,
+        hash(category_name, md5) -> hash_md5,
+        hash(category_name, sha1) -> hash_sha1,
+        hash(category_name, sha256) -> hash_sha256,
+        # hash(category_name, sha512) -> hash_sha512
     ;"""
     env, parsed = parse(declarations, environment=test_environment)
     select: SelectStatement = parsed[-1]
     for dialect in TEST_DIALECTS:
+        engine = None
+        if isinstance(dialect, DuckDBDialect):
+            engine = Dialects.DUCK_DB.default_executor(environment=test_environment)
         dialect.compile_statement(process_query(test_environment, select))
+        if engine:
+            engine.execute_raw_sql(
+                """CREATE TABLE tblCategory AS
+SELECT 
+    2 category_id,
+    'category_a' as category_name
+UNION ALL
+SELECT 
+    3 category_id,
+    'category_b' as category_name;"""
+            )
+            results = engine.execute_query(select)
+            assert results
+            assert results.fetchall()
 
 
 def test_case_function(test_environment):

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/tests/test_parse_engine.py

@@ -121,3 +121,17 @@ def test_alias_error():
     with raises(InvalidSyntaxException) as e:
         env.parse(TEXT2)
     assert ERROR_CODES[201] in str(e.value), e.value
+
+
+def test_semicolon_error():
+    env = Environment()
+    TEXT2 = """
+    const a <- 1;
+
+    select
+        a+2 as fun,
+    
+    """
+    with raises(InvalidSyntaxException) as e:
+        env.parse(TEXT2)
+    assert ERROR_CODES[202] in str(e.value), e.value

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

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/constants.py

@@ -1,7 +1,9 @@
 import random
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum
 from logging import getLogger
+from typing import Any
 
 logger = getLogger("trilogy")
 
@@ -29,6 +31,7 @@ class Optimizations:
     constant_inlining: bool = True
     constant_inline_cutoff: int = 10
     direct_return: bool = True
+    hide_unused_concepts: bool = True
 
 
 @dataclass
@@ -50,6 +53,32 @@ class Rendering:
     parameters: bool = True
     concise: bool = False
 
+    @contextmanager
+    def temporary(self, **kwargs: Any):
+        """
+        Context manager to temporarily set attributes and revert them afterwards.
+
+        Usage:
+            r = Rendering()
+            with r.temporary(parameters=False, concise=True):
+                # parameters is False, concise is True here
+                do_something()
+            # parameters and concise are back to their original values
+        """
+        # Store original values
+        original_values = {key: getattr(self, key) for key in kwargs}
+
+        # Set new values
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+        try:
+            yield self
+        finally:
+            # Restore original values
+            for key, value in original_values.items():
+                setattr(self, key, value)
+
 
 @dataclass
 class Parsing:

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/enums.py

@@ -169,6 +169,7 @@ class FunctionType(Enum):
     ARRAY_SORT = "array_sort"
     ARRAY_TRANSFORM = "array_transform"
     ARRAY_TO_STRING = "array_to_string"
+    ARRAY_FILTER = "array_filter"
 
     # MAP
     MAP_KEYS = "map_keys"
@@ -204,6 +205,7 @@ class FunctionType(Enum):
     MIN = "min"
     AVG = "avg"
     ARRAY_AGG = "array_agg"
+    ANY = "any"
 
     # String
     LIKE = "like"
@@ -215,6 +217,7 @@ class FunctionType(Enum):
     CONTAINS = "contains"
     TRIM = "trim"
     REPLACE = "replace"
+    HASH = "hash"
 
     # STRING REGEX
     REGEXP_CONTAINS = "regexp_contains"
@@ -244,6 +247,7 @@ class FunctionType(Enum):
     DATE_ADD = "date_add"
     DATE_SUB = "date_sub"
     DATE_DIFF = "date_diff"
+    DATE_SPINE = "date_spine"
 
     # UNIX
     UNIX_TO_TIMESTAMP = "unix_to_timestamp"
@@ -263,6 +267,7 @@ class FunctionClass(Enum):
         FunctionType.ARRAY_AGG,
         FunctionType.COUNT,
         FunctionType.COUNT_DISTINCT,
+        FunctionType.ANY,
     ]
     SINGLE_ROW = [
         FunctionType.CONSTANT,
@@ -270,7 +275,7 @@ class FunctionClass(Enum):
         FunctionType.CURRENT_DATETIME,
     ]
 
-    ONE_TO_MANY = [FunctionType.UNNEST]
+    ONE_TO_MANY = [FunctionType.UNNEST, FunctionType.DATE_SPINE]
 
     RECURSIVE = [FunctionType.RECURSE_EDGE]
 

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/functions.py

@@ -212,6 +212,14 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type_function=get_unnest_output_type,
         arg_count=1,
     ),
+    FunctionType.DATE_SPINE: FunctionConfig(
+        valid_inputs={
+            DataType.DATE,
+        },
+        output_purpose=Purpose.KEY,
+        output_type=DataType.DATE,
+        arg_count=2,
+    ),
     FunctionType.RECURSE_EDGE: FunctionConfig(
         arg_count=2,
     ),
@@ -318,6 +326,18 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type_function=get_transform_output_type,
         arg_count=3,
     ),
+    FunctionType.ARRAY_FILTER: FunctionConfig(
+        valid_inputs=[
+            {
+                DataType.ARRAY,
+            },
+            {*DataType},
+            {*DataType},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type_function=get_transform_output_type,
+        arg_count=3,
+    ),
     FunctionType.ARRAY_TO_STRING: FunctionConfig(
         valid_inputs={
             DataType.ARRAY,
@@ -887,6 +907,11 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         ),
         arg_count=1,
     ),
+    FunctionType.ANY: FunctionConfig(
+        valid_inputs={*DataType},
+        output_purpose=Purpose.PROPERTY,
+        arg_count=1,
+    ),
     FunctionType.AVG: FunctionConfig(
         valid_inputs={
             DataType.INTEGER,
@@ -903,6 +928,14 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.TIMESTAMP,
         arg_count=1,
     ),
+    FunctionType.HASH: FunctionConfig(
+        valid_inputs={
+            DataType.STRING,
+        },
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.STRING,
+        arg_count=2,
+    ),
 }
 
 EXCLUDED_FUNCTIONS = {

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/models/author.py

@@ -865,6 +865,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
             AggregateWrapper,
             RowsetItem,
             MultiSelectLineage,
+            Comparison,
         ]
     ] = None
     namespace: str = Field(default=DEFAULT_NAMESPACE, validate_default=True)
@@ -1079,6 +1080,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         | AggregateWrapper
         | RowsetItem
         | MultiSelectLineage
+        | Comparison
         | None,
         Grain,
         set[str] | None,
@@ -1178,6 +1180,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
                     AggregateWrapper,
                     RowsetItem,
                     MultiSelectLineage,
+                    Comparison,
                 ],
                 output: List[ConceptRef],
             ):
@@ -1204,6 +1207,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
     def calculate_derivation(self, lineage, purpose: Purpose) -> Derivation:
         from trilogy.core.models.build import (
             BuildAggregateWrapper,
+            BuildComparison,
             BuildFilterItem,
             BuildFunction,
             BuildMultiSelectLineage,
@@ -1221,6 +1225,8 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         #     return Derivation.PARENTHETICAL
         elif lineage and isinstance(lineage, (BuildRowsetItem, RowsetItem)):
             return Derivation.ROWSET
+        elif lineage and isinstance(lineage, BuildComparison):
+            return Derivation.BASIC
         elif lineage and isinstance(
             lineage, (BuildMultiSelectLineage, MultiSelectLineage)
         ):
@@ -1234,7 +1240,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         elif (
             lineage
             and isinstance(lineage, (BuildFunction, Function))
-            and lineage.operator == FunctionType.UNNEST
+            and lineage.operator in FunctionClass.ONE_TO_MANY.value
         ):
             return Derivation.UNNEST
         elif (
@@ -1286,7 +1292,8 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         elif (
             lineage
             and isinstance(lineage, (Function, BuildFunction))
-            and lineage.operator in (FunctionType.UNNEST, FunctionType.UNION)
+            and lineage.operator
+            in (FunctionType.UNNEST, FunctionType.UNION, FunctionType.DATE_SPINE)
         ):
             return Granularity.MULTI_ROW
         elif lineage and all(
@@ -2132,6 +2139,89 @@ class AlignClause(Namespaced, BaseModel):
         )
 
 
+class DeriveItem(Namespaced, DataTyped, ConceptArgs, Mergeable, BaseModel):
+    expr: Expr
+    name: str
+    namespace: str
+
+    @property
+    def derived_concept(self) -> str:
+        return f"{self.namespace}.{self.name}"
+        # return ConceptRef(
+        #     address=f"{self.namespace}.{self.name}",
+        #     datatype=arg_to_datatype(self.expr),
+        # )
+
+    def with_namespace(self, namespace):
+        return DeriveItem.model_construct(
+            expr=(self.expr.with_namespace(namespace) if self.expr else None),
+            name=self.name,
+            namespace=namespace,
+        )
+
+    def with_merge(
+        self, source: Concept, target: Concept, modifiers: List[Modifier]
+    ) -> "DeriveItem":
+        return DeriveItem.model_construct(
+            expr=(
+                self.expr.with_merge(source, target, modifiers)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+            name=self.name,
+            namespace=self.namespace,
+        )
+
+    def with_reference_replacement(self, source, target):
+        return DeriveItem.model_construct(
+            expr=(
+                self.expr.with_reference_replacement(source, target)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+            name=self.name,
+            namespace=self.namespace,
+        )
+
+
+class DeriveClause(Mergeable, Namespaced, BaseModel):
+    items: List[DeriveItem]
+
+    def with_namespace(self, namespace: str) -> "DeriveClause":
+        return DeriveClause.model_construct(
+            items=[
+                x.with_namespace(namespace) if isinstance(x, Namespaced) else x
+                for x in self.items
+            ]
+        )
+
+    def with_merge(
+        self, source: Concept, target: Concept, modifiers: List[Modifier]
+    ) -> "DeriveClause":
+        return DeriveClause.model_construct(
+            items=[
+                (
+                    x.with_merge(source, target, modifiers)
+                    if isinstance(x, Mergeable)
+                    else x
+                )
+                for x in self.items
+            ]
+        )
+
+    def with_reference_replacement(self, source, target):
+        return DeriveClause.model_construct(
+            items=[
+                (
+                    x.with_reference_replacement(source, target)
+                    if isinstance(x, Mergeable)
+                    else x
+                )
+                for x in self.items
+            ]
+        )
+
+
 class SelectLineage(Mergeable, Namespaced, BaseModel):
     selection: List[ConceptRef]
     hidden_components: set[str]
@@ -2176,15 +2266,40 @@ class SelectLineage(Mergeable, Namespaced, BaseModel):
             ),
         )
 
+    def with_namespace(self, namespace):
+        return SelectLineage.model_construct(
+            selection=[x.with_namespace(namespace) for x in self.selection],
+            hidden_components=self.hidden_components,
+            local_concepts={
+                x: y.with_namespace(namespace) for x, y in self.local_concepts.items()
+            },
+            order_by=self.order_by.with_namespace(namespace) if self.order_by else None,
+            limit=self.limit,
+            meta=self.meta,
+            grain=self.grain.with_namespace(namespace),
+            where_clause=(
+                self.where_clause.with_namespace(namespace)
+                if self.where_clause
+                else None
+            ),
+            having_clause=(
+                self.having_clause.with_namespace(namespace)
+                if self.having_clause
+                else None
+            ),
+        )
+
 
 class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
     selects: List[SelectLineage]
     align: AlignClause
+
     namespace: str
     order_by: Optional[OrderBy] = None
     limit: Optional[int] = None
     where_clause: Union["WhereClause", None] = Field(default=None)
     having_clause: Union["HavingClause", None] = Field(default=None)
+    derive: DeriveClause | None = None
     hidden_components: set[str]
 
     @property
@@ -2210,6 +2325,11 @@ class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
         new = MultiSelectLineage.model_construct(
             selects=[s.with_merge(source, target, modifiers) for s in self.selects],
             align=self.align,
+            derive=(
+                self.derive.with_merge(source, target, modifiers)
+                if self.derive
+                else None
+            ),
             namespace=self.namespace,
             hidden_components=self.hidden_components,
             order_by=(
@@ -2235,6 +2355,7 @@ class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
         return MultiSelectLineage.model_construct(
             selects=[c.with_namespace(namespace) for c in self.selects],
             align=self.align.with_namespace(namespace),
+            derive=self.derive.with_namespace(namespace) if self.derive else None,
             namespace=namespace,
             hidden_components=self.hidden_components,
             order_by=self.order_by.with_namespace(namespace) if self.order_by else None,
@@ -2256,6 +2377,9 @@ class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
         output = set()
         for item in self.align.items:
             output.add(item.aligned_concept)
+        if self.derive:
+            for ditem in self.derive.items:
+                output.add(ditem.derived_concept)
         return output
 
     @property

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/models/build.py

@@ -48,6 +48,8 @@ from trilogy.core.models.author import (
     Concept,
     ConceptRef,
     Conditional,
+    DeriveClause,
+    DeriveItem,
     FilterItem,
     FuncArgs,
     Function,
@@ -134,8 +136,9 @@ def concept_is_relevant(
     if concept.purpose in (Purpose.METRIC,):
         if all([c in others for c in concept.grain.components]):
             return False
+    if concept.derivation in (Derivation.UNNEST,):
+        return True
     if concept.derivation in (Derivation.BASIC,):
-
         return any(concept_is_relevant(c, others) for c in concept.concept_arguments)
     if concept.granularity == Granularity.SINGLE_ROW:
         return False
@@ -246,7 +249,7 @@ class BuildParamaterizedConceptReference(DataTyped):
     concept: BuildConcept
 
     def __str__(self):
-        return f":{self.concept.address}"
+        return f":{self.concept.address.replace('.', '_')}"
 
     @property
     def safe_address(self) -> str:
@@ -1267,6 +1270,22 @@ class BuildAlignClause:
     items: List[BuildAlignItem]
 
 
+@dataclass
+class BuildDeriveClause:
+    items: List[BuildDeriveItem]
+
+
+@dataclass
+class BuildDeriveItem:
+    expr: BuildExpr
+    name: str
+    namespace: str = field(default=DEFAULT_NAMESPACE)
+
+    @property
+    def address(self) -> str:
+        return f"{self.namespace}.{self.name}"
+
+
 @dataclass
 class BuildSelectLineage:
     selection: List[BuildConcept]
@@ -1298,12 +1317,16 @@ class BuildMultiSelectLineage(BuildConceptArgs):
     limit: Optional[int] = None
     where_clause: Union["BuildWhereClause", None] = field(default=None)
     having_clause: Union["BuildHavingClause", None] = field(default=None)
+    derive: BuildDeriveClause | None = None
 
     @property
     def derived_concepts(self) -> set[str]:
         output = set()
         for item in self.align.items:
             output.add(item.aligned_concept)
+        if self.derive:
+            for ditem in self.derive.items:
+                output.add(ditem.address)
         return output
 
     @property
@@ -1311,10 +1334,12 @@ class BuildMultiSelectLineage(BuildConceptArgs):
         return self.build_output_components
 
     @property
-    def derived_concept(self) -> set[str]:
-        output = set()
-        for item in self.align.items:
-            output.add(item.aligned_concept)
+    def calculated_derivations(self) -> set[str]:
+        output: set[str] = set()
+        if not self.derive:
+            return output
+        for item in self.derive.items:
+            output.add(item.address)
         return output
 
     @property
@@ -1334,6 +1359,7 @@ class BuildMultiSelectLineage(BuildConceptArgs):
                 for c in x.concepts:
                     if c.address in cte.output_lcl:
                         return c
+
         raise SyntaxError(
             f"Could not find upstream map for multiselect {str(concept)} on cte ({cte})"
         )
@@ -1668,7 +1694,6 @@ class Factory:
                     valid_inputs=base.valid_inputs,
                     arg_count=base.arg_count,
                 )
-
         new = BuildFunction(
             operator=base.operator,
             arguments=[self.handle_constant(self.build(c)) for c in raw_args],
@@ -1724,6 +1749,14 @@ class Factory:
         return self._build_concept(base)
 
     def _build_concept(self, base: Concept) -> BuildConcept:
+        try:
+            return self.__build_concept(base)
+        except RecursionError as e:
+            raise RecursionError(
+                f"Recursion error building concept {base.address}. This is likely due to a circular reference."
+            ) from e
+
+    def __build_concept(self, base: Concept) -> BuildConcept:
         # TODO: if we are using parameters, wrap it in a new model and use that in rendering
         if base.address in self.local_concepts:
             return self.local_concepts[base.address]
@@ -1953,6 +1986,28 @@ class Factory:
     def _build_align_clause(self, base: AlignClause) -> BuildAlignClause:
         return BuildAlignClause(items=[self._build_align_item(x) for x in base.items])
 
+    @build.register
+    def _(self, base: DeriveItem) -> BuildDeriveItem:
+        return self._build_derive_item(base)
+
+    def _build_derive_item(self, base: DeriveItem) -> BuildDeriveItem:
+        expr: Concept | FuncArgs = base.expr
+        validation = requires_concept_nesting(expr)
+        if validation:
+            expr, _ = self.instantiate_concept(validation)
+        return BuildDeriveItem(
+            expr=self.build(expr),
+            name=base.name,
+            namespace=base.namespace,
+        )
+
+    @build.register
+    def _(self, base: DeriveClause) -> BuildDeriveClause:
+        return self._build_derive_clause(base)
+
+    def _build_derive_clause(self, base: DeriveClause) -> BuildDeriveClause:
+        return BuildDeriveClause(items=[self.build(x) for x in base.items])
+
     @build.register
     def _(self, base: RowsetItem) -> BuildRowsetItem:
         return self._build_rowset_item(base)
@@ -2002,6 +2057,13 @@ class Factory:
     def _build_tuple_wrapper(self, base: TupleWrapper) -> TupleWrapper:
         return TupleWrapper(val=[self.build(x) for x in base.val], type=base.type)
 
+    @build.register
+    def _(self, base: ListWrapper) -> ListWrapper:
+        return self._build_list_wrapper(base)
+
+    def _build_list_wrapper(self, base: ListWrapper) -> ListWrapper:
+        return ListWrapper([self.build(x) for x in base], type=base.type)
+
     @build.register
     def _(self, base: FilterItem) -> BuildFilterItem:
         return self._build_filter_item(base)
@@ -2147,6 +2209,7 @@ class Factory:
             selects=base.selects,
             grain=final_grain,
             align=factory.build(base.align),
+            derive=factory.build(base.derive) if base.derive else None,
             # self.align.with_select_context(
             #     local_build_cache, self.grain, environment
             # ),

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/models/environment.py

@@ -413,7 +413,8 @@ class Environment(BaseModel):
             self.imports[alias].append(imp_stm)
         # we can't exit early
         # as there may be new concepts
-        for k, concept in source.concepts.items():
+        iteration: list[tuple[str, Concept]] = list(source.concepts.items())
+        for k, concept in iteration:
             # skip internal namespace
             if INTERNAL_NAMESPACE in concept.address:
                 continue

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/optimization.py

@@ -228,7 +228,8 @@ def optimize_ctes(
         REGISTERED_RULES.append(PredicatePushdown())
     if CONFIG.optimizations.predicate_pushdown:
         REGISTERED_RULES.append(PredicatePushdownRemove())
-    REGISTERED_RULES.append(HideUnusedConcepts())
+    if CONFIG.optimizations.hide_unused_concepts:
+        REGISTERED_RULES.append(HideUnusedConcepts())
     for rule in REGISTERED_RULES:
         loops = 0
         complete = False
@@ -242,7 +243,7 @@ def optimize_ctes(
                 actions_taken = actions_taken or opt
             complete = not actions_taken
             loops += 1
-            input = reorder_ctes(filter_irrelevant_ctes(input, root_cte))
+        input = reorder_ctes(filter_irrelevant_ctes(input, root_cte))
         logger.info(
             f"[Optimization] Finished checking for {type(rule).__name__} after {loops} loop(s)"
         )

{pytrilogy-0.0.3.113 → pytrilogy-0.0.3.116}/trilogy/core/optimizations/hide_unused_concept.py

@@ -39,11 +39,7 @@ class HideUnusedConcepts(OptimizationRule):
         self.log(
             f"Hiding unused concepts {[x.address for x in add_to_hidden]} from {cte.name} (used: {used}, all: {[x.address for x in cte.output_columns]})"
         )
-        candidates = [
-            x.address
-            for x in cte.output_columns
-            if x.address not in used and x.address not in cte.hidden_concepts
-        ]
+        candidates = [x.address for x in cte.output_columns if x.address not in used]
         if len(candidates) == len(set([x.address for x in cte.output_columns])):
             # pop one out
             candidates.pop()