pytrilogy 0.0.2.56__tar.gz → 0.0.2.58__tar.gz

{pytrilogy-0.0.2.56/pytrilogy.egg-info → pytrilogy-0.0.2.58}/PKG-INFO

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

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/tests/test_models.py

@@ -147,12 +147,14 @@ def test_select(test_environment: Environment):
     pid = test_environment.concepts["product_id"]
     cid = test_environment.concepts["category_id"]
     cname = test_environment.concepts["category_name"]
-    x = SelectStatement(selection=[oid, pid, cid, cname])
+    x = SelectStatement(
+        selection=[oid, pid, cid, cname], grain=Grain(components=[oid, pid, cid])
+    )
     ds = x.to_datasource(
         test_environment.namespace, "test", address=Address(location="test")
     )
 
-    assert ds.grain == Grain(components=[oid, pid, cid])
+    assert ds.grain.components == Grain(components=[oid, pid, cid]).components
 
 
 def test_undefined(test_environment: Environment):

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/tests/test_select.py

@@ -123,7 +123,7 @@ def test_modifiers():
     ;"""
     env, parsed = parse(q1)
     select: SelectStatement = parsed[-1]
-    assert select.hidden_components == [env.concepts["b"]]
+    assert select.hidden_components == set([env.concepts["b"].address])
     assert select.output_components == [env.concepts["a"], env.concepts["b"]]
     query = process_query(statement=select, environment=env)
 

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

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/functions.py

@@ -127,10 +127,11 @@ def Unnest(args: list[Concept]) -> Function:
 
 def Group(args: list[Concept]) -> Function:
     output = args[0]
+    datatype = arg_to_datatype(output)
     return Function(
         operator=FunctionType.GROUP,
         arguments=args,
-        output_datatype=output.datatype,
+        output_datatype=datatype,
         output_purpose=Purpose.PROPERTY,
         arg_count=-1,
     )

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/models.py

@@ -923,9 +923,16 @@ class Grain(Namespaced, BaseModel):
             if not self.where_clause:
                 where = other.where_clause
             elif not other.where_clause == self.where_clause:
-                raise NotImplementedError(
-                    f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
+                where = WhereClause(
+                    conditional=Conditional(
+                        left=self.where_clause.conditional,
+                        right=other.where_clause.conditional,
+                        operator=BooleanOperator.AND,
+                    )
                 )
+                # raise NotImplementedError(
+                #     f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
+                # )
         return Grain(
             components=self.components.union(other.components), where_clause=where
         )
@@ -1863,11 +1870,11 @@ class SelectStatement(HasUUID, Mergeable, Namespaced, SelectTypeMixin, BaseModel
         return output
 
     @property
-    def hidden_components(self) -> List[Concept]:
-        output = []
+    def hidden_components(self) -> set[str]:
+        output = set()
         for item in self.selection:
             if isinstance(item, SelectItem) and Modifier.HIDDEN in item.modifiers:
-                output.append(item.output)
+                output.add(item.output.address)
         return output
 
     @property
@@ -2097,10 +2104,10 @@ class MultiSelectStatement(HasUUID, SelectTypeMixin, Mergeable, Namespaced, Base
 
     @computed_field  # type: ignore
     @cached_property
-    def hidden_components(self) -> List[Concept]:
-        output = []
+    def hidden_components(self) -> set[str]:
+        output: set[str] = set()
         for select in self.selects:
-            output += select.hidden_components
+            output = output.union(select.hidden_components)
         return output
 
 
@@ -2182,6 +2189,10 @@ class Datasource(HasUUID, Namespaced, BaseModel):
     def duplicate(self) -> Datasource:
         return self.model_copy(deep=True)
 
+    @property
+    def hidden_concepts(self) -> List[Concept]:
+        return []
+
     def merge_concept(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
     ):
@@ -2254,17 +2265,7 @@ class Datasource(HasUUID, Namespaced, BaseModel):
     @field_validator("grain", mode="before")
     @classmethod
     def grain_enforcement(cls, v: Grain, info: ValidationInfo):
-        values = info.data
         grain: Grain = safe_grain(v)
-        if not grain.components:
-            columns: List[ColumnAssignment] = values.get("columns", [])
-            grain = Grain.from_concepts(
-                [
-                    c.concept.with_grain(Grain())
-                    for c in columns
-                    if c.concept.purpose == Purpose.KEY
-                ]
-            )
         return grain
 
     def add_column(
@@ -2507,7 +2508,7 @@ class QueryDatasource(BaseModel):
     filter_concepts: List[Concept] = Field(default_factory=list)
     source_type: SourceType = SourceType.SELECT
     partial_concepts: List[Concept] = Field(default_factory=list)
-    hidden_concepts: List[Concept] = Field(default_factory=list)
+    hidden_concepts: set[str] = Field(default_factory=set)
     nullable_concepts: List[Concept] = Field(default_factory=list)
     join_derived_concepts: List[Concept] = Field(default_factory=list)
     force_group: bool | None = None
@@ -2659,10 +2660,10 @@ class QueryDatasource(BaseModel):
             final_source_map[k] = set(
                 merged_datasources.get(x.safe_identifier, x) for x in list(v)
             )
-        self_hidden = self.hidden_concepts or []
-        other_hidden = other.hidden_concepts or []
+        self_hidden: set[str] = self.hidden_concepts or set()
+        other_hidden: set[str] = other.hidden_concepts or set()
         # hidden is the minimum overlapping set
-        hidden = [x for x in self_hidden if x.address in other_hidden]
+        hidden = self_hidden.intersection(other_hidden)
         qds = QueryDatasource(
             input_concepts=unique(
                 self.input_concepts + other.input_concepts, "address"
@@ -2760,7 +2761,7 @@ class CTE(BaseModel):
     partial_concepts: List[Concept] = Field(default_factory=list)
     nullable_concepts: List[Concept] = Field(default_factory=list)
     join_derived_concepts: List[Concept] = Field(default_factory=list)
-    hidden_concepts: List[Concept] = Field(default_factory=list)
+    hidden_concepts: set[str] = Field(default_factory=set)
     order_by: Optional[OrderBy] = None
     limit: Optional[int] = None
     base_name_override: Optional[str] = None
@@ -2946,10 +2947,10 @@ class CTE(BaseModel):
                 f" {self.name} {other.name} conditions {self.condition} {other.condition}"
             )
             raise ValueError(error)
-        mutually_hidden = []
+        mutually_hidden = set()
         for concept in self.hidden_concepts:
-            if concept.address in other.hidden_concepts:
-                mutually_hidden.append(concept)
+            if concept in other.hidden_concepts:
+                mutually_hidden.add(concept)
         self.partial_concepts = unique(
             self.partial_concepts + other.partial_concepts, "address"
         )
@@ -3073,12 +3074,18 @@ class CTE(BaseModel):
                 assert isinstance(c.lineage, RowsetItem)
                 return check_is_not_in_group(c.lineage.content)
             if c.derivation == PurposeLineage.CONSTANT:
-                return False
+                return True
             if c.purpose == Purpose.METRIC:
                 return True
-            elif c.derivation == PurposeLineage.BASIC and c.lineage:
+
+            if c.derivation == PurposeLineage.BASIC and c.lineage:
                 if all([check_is_not_in_group(x) for x in c.lineage.concept_arguments]):
                     return True
+                if (
+                    isinstance(c.lineage, Function)
+                    and c.lineage.operator == FunctionType.GROUP
+                ):
+                    return check_is_not_in_group(c.lineage.concept_arguments[0])
             return False
 
         return (
@@ -3125,7 +3132,7 @@ class UnionCTE(BaseModel):
     operator: str = "UNION ALL"
     order_by: Optional[OrderBy] = None
     limit: Optional[int] = None
-    hidden_concepts: list[Concept] = Field(default_factory=list)
+    hidden_concepts: set[str] = Field(default_factory=set)
     partial_concepts: list[Concept] = Field(default_factory=list)
     existence_source_map: Dict[str, list[str]] = Field(default_factory=dict)
 
@@ -3756,6 +3763,7 @@ class Environment(BaseModel):
         for k, v in self.concepts.items():
             if v.address == target.address:
                 v.pseudonyms.add(source.address)
+
             if v.address == source.address:
                 replacements[k] = target
                 v.pseudonyms.add(target.address)
@@ -4496,7 +4504,7 @@ class ProcessedQuery(BaseModel):
     base: CTE | UnionCTE
     joins: List[Join]
     grain: Grain
-    hidden_columns: List[Concept] = Field(default_factory=list)
+    hidden_columns: set[str] = Field(default_factory=set)
     limit: Optional[int] = None
     where_clause: Optional[WhereClause] = None
     having_clause: Optional[HavingClause] = None

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/optimization.py

@@ -136,15 +136,12 @@ def is_direct_return_eligible(cte: CTE | UnionCTE) -> CTE | UnionCTE | None:
 
     assert isinstance(cte, CTE)
     derived_concepts = [
-        c
-        for c in cte.source.output_concepts + cte.source.hidden_concepts
-        if c not in cte.source.input_concepts
+        c for c in cte.source.output_concepts if c not in cte.source.input_concepts
     ]
 
     parent_derived_concepts = [
         c
         for c in direct_parent.source.output_concepts
-        + direct_parent.source.hidden_concepts
         if c not in direct_parent.source.input_concepts
     ]
     condition_arguments = cte.condition.row_arguments if cte.condition else []
@@ -180,8 +177,8 @@ def optimize_ctes(
     ):
         direct_parent.order_by = root_cte.order_by
         direct_parent.limit = root_cte.limit
-        direct_parent.hidden_concepts = (
-            root_cte.hidden_concepts + direct_parent.hidden_concepts
+        direct_parent.hidden_concepts = root_cte.hidden_concepts.union(
+            direct_parent.hidden_concepts
         )
         if root_cte.condition:
             if direct_parent.condition:

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/concept_strategies_v3.py

@@ -539,11 +539,14 @@ def validate_concept(
             found_addresses.add(concept.address)
             found_map[str(node)].add(concept)
     for v_address in concept.pseudonyms:
+        if v_address in seen:
+            return
         v = environment.concepts[v_address]
-        if v == concept.address:
+        if v.address in seen:
             return
-        if v in seen:
+        if v.address == concept.address:
             return
+
         validate_concept(
             v,
             node,
@@ -577,7 +580,7 @@ def validate_stack(
         resolved = node.resolve()
 
         for concept in resolved.output_concepts:
-            if concept in resolved.hidden_concepts:
+            if concept.address in resolved.hidden_concepts:
                 continue
             validate_concept(
                 concept,
@@ -988,17 +991,20 @@ def source_query_concepts(
         raise ValueError(
             f"Could not resolve conections between {error_strings} from environment graph."
         )
-    candidate = GroupNode(
-        output_concepts=[
-            x for x in root.output_concepts if x.address not in root.hidden_concepts
-        ],
-        input_concepts=[
-            x for x in root.output_concepts if x.address not in root.hidden_concepts
-        ],
+    final = [x for x in root.output_concepts if x.address not in root.hidden_concepts]
+    if GroupNode.check_if_required(
+        downstream_concepts=final,
+        parents=[root.resolve()],
         environment=environment,
-        parents=[root],
-        partial_concepts=root.partial_concepts,
-    )
-    if not candidate.resolve().group_required:
-        return root
+    ).required:
+        candidate: StrategyNode = GroupNode(
+            output_concepts=final,
+            input_concepts=final,
+            environment=environment,
+            parents=[root],
+            partial_concepts=root.partial_concepts,
+        )
+    else:
+        candidate = root
+
     return candidate

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/node_generators/basic_node.py

@@ -13,6 +13,7 @@ from trilogy.core.processing.node_generators.common import (
     resolve_function_parent_concepts,
 )
 from trilogy.core.processing.nodes import History, StrategyNode
+from trilogy.utility import unique
 
 LOGGER_PREFIX = "[GEN_BASIC_NODE]"
 
@@ -65,7 +66,9 @@ def gen_basic_node(
     non_equivalent_optional = [
         x for x in local_optional if x not in equivalent_optional
     ]
-    all_parents = parent_concepts + non_equivalent_optional
+    all_parents: list[Concept] = unique(
+        parent_concepts + non_equivalent_optional, "address"
+    )
     logger.info(
         f"{depth_prefix}{LOGGER_PREFIX} Fetching parents {[x.address for x in all_parents]}"
     )

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/node_generators/common.py

@@ -208,7 +208,7 @@ def gen_enrichment_node(
     non_hidden = [
         x
         for x in base_node.output_concepts
-        if x.address not in [y.address for y in base_node.hidden_concepts]
+        if x.address not in base_node.hidden_concepts
     ]
     return MergeNode(
         input_concepts=unique(join_keys + extra_required + non_hidden, "address"),

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/node_generators/group_to_node.py

@@ -26,6 +26,7 @@ def gen_group_to_node(
     # aggregates MUST always group to the proper grain
     if not isinstance(concept.lineage, Function):
         raise SyntaxError("Group to should have function lineage")
+    group_arg = concept.lineage.arguments[0]
     parent_concepts: List[Concept] = concept.lineage.concept_arguments
     logger.info(
         f"{padding(depth)}{LOGGER_PREFIX} group by node has required parents {[x.address for x in parent_concepts]}"
@@ -47,6 +48,13 @@ def gen_group_to_node(
         environment=environment,
         parents=parents,
         depth=depth,
+        preexisting_conditions=conditions.conditional if conditions else None,
+        hidden_concepts=set(
+            [group_arg.address]
+            if isinstance(group_arg, Concept)
+            and group_arg.address not in local_optional
+            else []
+        ),
     )
 
     # early exit if no optional
@@ -62,6 +70,7 @@ def gen_group_to_node(
         g=g,
         depth=depth + 1,
         history=history,
+        conditions=conditions,
     )
     if not enrich_node:
         logger.info(
@@ -83,4 +92,5 @@ def gen_group_to_node(
         ],
         whole_grain=True,
         depth=depth,
+        preexisting_conditions=conditions.conditional if conditions else None,
     )

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/node_generators/multiselect_node.py

@@ -69,6 +69,7 @@ def gen_multiselect_node(
     lineage: MultiSelectStatement = concept.lineage
 
     base_parents: List[StrategyNode] = []
+    partial = []
     for select in lineage.selects:
         snode: StrategyNode = source_concepts(
             mandatory_list=select.output_components,
@@ -103,6 +104,9 @@ def gen_multiselect_node(
         for mc in merge_concepts:
             assert mc in snode.resolve().output_concepts
         base_parents.append(snode)
+        if select.where_clause:
+            for item in select.output_components:
+                partial.append(item)
 
     node_joins = extra_align_joins(lineage, base_parents)
     node = MergeNode(
@@ -112,35 +116,28 @@ def gen_multiselect_node(
         depth=depth,
         parents=base_parents,
         node_joins=node_joins,
+        hidden_concepts=set([x for y in base_parents for x in y.hidden_concepts]),
     )
 
     enrichment = set([x.address for x in local_optional])
 
-    rowset_relevant = [
+    multiselect_relevant = [
         x
         for x in lineage.derived_concepts
         if x.address == concept.address or x.address in enrichment
     ]
-    additional_relevant = [
-        x for x in select.output_components if x.address in enrichment
-    ]
+    additional_relevant = [x for x in node.output_concepts if x.address in enrichment]
     # add in other other concepts
-    for item in rowset_relevant:
-        node.output_concepts.append(item)
-    for item in additional_relevant:
-        node.output_concepts.append(item)
-    if select.where_clause:
-        for item in additional_relevant:
-            node.partial_concepts.append(item)
 
-    # we need a better API for refreshing a nodes QDS
-    node.resolution_cache = node._resolve()
+    node.set_output_concepts(multiselect_relevant + additional_relevant)
 
-    # assume grain to be output of select
-    # but don't include anything aggregate at this point
-    node.resolution_cache.grain = Grain.from_concepts(
-        node.output_concepts,
-    )
+    # node.add_partial_concepts(partial)
+    # if select.where_clause:
+    #     for item in additional_relevant:
+    #         node.partial_concepts.append(item)
+    node.grain = Grain.from_concepts(node.output_concepts, environment=environment)
+    node.rebuild_cache()
+    # we need a better API for refreshing a nodes QDS
     possible_joins = concept_to_relevant_joins(additional_relevant)
     if not local_optional:
         logger.info(
@@ -159,6 +156,7 @@ def gen_multiselect_node(
             f"{padding(depth)}{LOGGER_PREFIX} all enriched concepts returned from base rowset node; exiting early"
         )
         return node
+
     enrich_node: MergeNode = source_concepts(  # this fetches the parent + join keys
         # to then connect to the rest of the query
         mandatory_list=additional_relevant + local_optional,

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/node_generators/rowset_node.py

@@ -47,7 +47,7 @@ def gen_rowset_node(
         return None
     enrichment = set([x.address for x in local_optional])
     rowset_relevant = [x for x in rowset.derived_concepts]
-    select_hidden = set([x.address for x in select.hidden_components])
+    select_hidden = select.hidden_components
     rowset_hidden = [
         x
         for x in rowset.derived_concepts
@@ -80,7 +80,9 @@ def gen_rowset_node(
             for x in node.output_concepts
             if x.address
             not in [
-                y for y in node.hidden_concepts if y.derivation != PurposeLineage.ROWSET
+                y
+                for y in node.hidden_concepts
+                if environment.concepts[y].derivation != PurposeLineage.ROWSET
             ]
         ],
     )
@@ -103,6 +105,7 @@ def gen_rowset_node(
         )
         return node
     if any(x.derivation == PurposeLineage.ROWSET for x in possible_joins):
+
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} cannot enrich rowset node with rowset concepts; exiting early"
         )

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -240,10 +240,12 @@ def create_datasource_node(
     depth: int,
     conditions: WhereClause | None = None,
 ) -> tuple[StrategyNode, bool]:
-    target_grain = Grain.from_concepts(all_concepts)
+    target_grain = Grain.from_concepts(all_concepts, environment=environment)
     force_group = False
     if not datasource.grain.issubset(target_grain):
         force_group = True
+    if not datasource.grain.components:
+        force_group = True
     partial_concepts = [
         c.concept
         for c in datasource.columns
@@ -350,6 +352,9 @@ def create_select_node(
 
     # we need to nest the group node one further
     if force_group is True:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} source requires group before consumption."
+        )
         candidate: StrategyNode = GroupNode(
             output_concepts=all_concepts,
             input_concepts=all_concepts,
@@ -359,8 +364,10 @@ def create_select_node(
             partial_concepts=bcandidate.partial_concepts,
             nullable_concepts=bcandidate.nullable_concepts,
             preexisting_conditions=bcandidate.preexisting_conditions,
+            force_group=force_group,
         )
     else:
+
         candidate = bcandidate
     return candidate
 

{pytrilogy-0.0.2.56 → pytrilogy-0.0.2.58}/trilogy/core/processing/nodes/base_node.py

@@ -40,9 +40,10 @@ def resolve_concept_map(
         for concept in input.output_concepts:
             if concept.address not in input.non_partial_concept_addresses:
                 continue
-            if isinstance(input, QueryDatasource) and concept.address in [
-                x.address for x in input.hidden_concepts
-            ]:
+            if (
+                isinstance(input, QueryDatasource)
+                and concept.address in input.hidden_concepts
+            ):
                 continue
             if concept.address in full_addresses:
                 concept_map[concept.address].add(input)
@@ -138,7 +139,7 @@ class StrategyNode:
         preexisting_conditions: Conditional | Comparison | Parenthetical | None = None,
         force_group: bool | None = None,
         grain: Optional[Grain] = None,
-        hidden_concepts: List[Concept] | None = None,
+        hidden_concepts: set[str] | None = None,
         existence_concepts: List[Concept] | None = None,
         virtual_output_concepts: List[Concept] | None = None,
     ):
@@ -165,7 +166,7 @@ class StrategyNode:
         self.grain = grain
         self.force_group = force_group
         self.tainted = False
-        self.hidden_concepts = hidden_concepts or []
+        self.hidden_concepts = hidden_concepts or set()
         self.existence_concepts = existence_concepts or []
         self.virtual_output_concepts = virtual_output_concepts or []
         self.preexisting_conditions = preexisting_conditions
@@ -192,6 +193,8 @@ class StrategyNode:
         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)
         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(
@@ -246,6 +249,15 @@ class StrategyNode:
             self.rebuild_cache()
         return self
 
+    def add_partial_concepts(self, concepts: List[Concept], rebuild: bool = True):
+        for concept in concepts:
+            if concept.address not in self.partial_lcl.addresses:
+                self.partial_concepts.append(concept)
+        self.partial_lcl = LooseConceptList(concepts=self.partial_concepts)
+        if rebuild:
+            self.rebuild_cache()
+        return self
+
     def add_existence_concepts(self, concepts: List[Concept], rebuild: bool = True):
         for concept in concepts:
             if concept.address not in self.output_concepts:
@@ -270,22 +282,20 @@ class StrategyNode:
 
     def hide_output_concepts(self, concepts: List[Concept], rebuild: bool = True):
         for x in concepts:
-            self.hidden_concepts.append(x)
+            self.hidden_concepts.add(x.address)
         if rebuild:
             self.rebuild_cache()
         return self
 
     def unhide_output_concepts(self, concepts: List[Concept], rebuild: bool = True):
-        self.hidden_concepts = [
-            x for x in self.hidden_concepts if x.address not in concepts
-        ]
+        self.hidden_concepts = set(x for x in self.hidden_concepts if x not in concepts)
         if rebuild:
             self.rebuild_cache()
         return self
 
     def remove_output_concepts(self, concepts: List[Concept], rebuild: bool = True):
         for x in concepts:
-            self.hidden_concepts.append(x)
+            self.hidden_concepts.add(x.address)
         addresses = [x.address for x in concepts]
         self.output_concepts = [
             x for x in self.output_concepts if x.address not in addresses
@@ -377,7 +387,7 @@ class StrategyNode:
             preexisting_conditions=self.preexisting_conditions,
             force_group=self.force_group,
             grain=self.grain,
-            hidden_concepts=list(self.hidden_concepts),
+            hidden_concepts=set(self.hidden_concepts),
             existence_concepts=list(self.existence_concepts),
             virtual_output_concepts=list(self.virtual_output_concepts),
         )