infrahub-server 1.7.0b0__py3-none-any.whl → 1.7.1__py3-none-any.whl

infrahub/core/query/relationship.py

@@ -14,7 +14,7 @@ from infrahub.core.changelog.models import (
 )
 from infrahub.core.constants import InfrahubKind, MetadataOptions, RelationshipDirection, RelationshipStatus
 from infrahub.core.constants.database import DatabaseEdgeType
-from infrahub.core.query import Query, QueryType
+from infrahub.core.query import Query, QueryResult, QueryType
 from infrahub.core.query.subquery import build_subquery_filter, build_subquery_order
 from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import extract_field_filters
@@ -159,7 +159,7 @@ class RelationshipQuery(Query):
         branch: Branch | None = None,
         at: Timestamp | str | None = None,
         **kwargs,
-    ):
+    ) -> None:
         if not source and not source_id:
             raise ValueError("Either source or source_id must be provided.")
         if not rel and not rel_id:
@@ -278,7 +278,7 @@ class RelationshipCreateQuery(RelationshipQuery):
         destination: Node = None,
         destination_id: UUID | None = None,
         **kwargs,
-    ):
+    ) -> None:
         if not destination and not destination_id:
             raise ValueError("Either destination or destination_id must be provided.")
 
@@ -399,7 +399,7 @@ class RelationshipUpdatePropertyQuery(RelationshipQuery):
         flag_properties_to_update: dict[str, bool],
         node_properties_to_update: dict[str, str],
         **kwargs,
-    ):
+    ) -> None:
         if not flag_properties_to_update and not node_properties_to_update:
             raise ValueError("Either flag_properties_to_update or node_properties_to_update must be set")
         self.flag_properties_to_update = flag_properties_to_update
@@ -557,7 +557,7 @@ class RelationshipDeleteQuery(RelationshipQuery):
     insert_return = False
     raise_error_if_empty = False
 
-    def __init__(self, source_branch: Branch, destination_branch: Branch, **kwargs):
+    def __init__(self, source_branch: Branch, destination_branch: Branch, **kwargs) -> None:
         self.source_branch = source_branch
         self.destination_branch = destination_branch
         super().__init__(**kwargs)
@@ -690,7 +690,7 @@ class RelationshipGetPeerQuery(Query):
         at: Timestamp | str | None = None,
         include_metadata: MetadataOptions = MetadataOptions.NONE,
         **kwargs,
-    ):
+    ) -> None:
         if not source and not source_ids:
             raise ValueError("Either source or source_ids must be provided.")
         if not rel and not rel_type:
@@ -1124,6 +1124,25 @@ class RelationshipGetByIdentifierQuery(Query):
             yield data
 
 
+@dataclass(frozen=True)
+class RelationshipCountPerNodeResult:
+    """Result from RelationshipCountPerNodeQuery containing peer count info."""
+
+    peer_uuid: str
+    """UUID of the peer node."""
+
+    count: int
+    """Number of relationship peers for this node."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> RelationshipCountPerNodeResult:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            peer_uuid=result.get_as_type("peer_node.uuid", str),
+            count=result.get_as_type("nbr_peers", int),
+        )
+
+
 class RelationshipCountPerNodeQuery(Query):
     name = "relationship_count_per_node"
     type: QueryType = QueryType.READ
@@ -1134,7 +1153,7 @@ class RelationshipCountPerNodeQuery(Query):
         identifier: str,
         direction: RelationshipDirection,
         **kwargs,
-    ):
+    ) -> None:
         self.node_ids = node_ids
         self.identifier = identifier
         self.direction = direction
@@ -1172,10 +1191,18 @@ class RelationshipCountPerNodeQuery(Query):
         self.order_by = ["peer_node.uuid"]
         self.return_labels = ["peer_node.uuid", "COUNT(peer_node.uuid) as nbr_peers"]
 
+    def get_data(self) -> list[RelationshipCountPerNodeResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of RelationshipCountPerNodeResult containing peer count info.
+        """
+        return [RelationshipCountPerNodeResult.from_db(result) for result in self.get_results()]
+
     async def get_count_per_peer(self) -> dict[str, int]:
         data: dict[str, int] = {}
-        for result in self.results:
-            data[result.get("peer_node.uuid")] = result.get("nbr_peers")
+        for item in self.get_data():
+            data[item.peer_uuid] = item.count
 
         for node_id in self.node_ids:
             if node_id not in data:
@@ -1184,6 +1211,33 @@ class RelationshipCountPerNodeQuery(Query):
         return data
 
 
+@dataclass(frozen=True)
+class RelationshipDeleteAllQueryResult:
+    """Result from RelationshipDeleteAllQuery containing deleted relationship info."""
+
+    uuid: str
+    """UUID of the peer node whose relationship was deleted."""
+
+    kind: str
+    """Kind/type of the peer node."""
+
+    rel_identifier: str
+    """Relationship schema identifier name."""
+
+    rel_direction: str
+    """Direction of the relationship ("outbound" or "inbound")."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> RelationshipDeleteAllQueryResult:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            uuid=result.get_as_type("uuid", str),
+            kind=result.get_as_type("kind", str),
+            rel_identifier=result.get_as_type("rel_identifier", str),
+            rel_direction=result.get_as_type("rel_direction", str),
+        )
+
+
 class RelationshipDeleteAllQuery(Query):
     """
     Delete all relationships linked to a given node on a given branch at a given time. For every IS_RELATED edge:
@@ -1198,7 +1252,7 @@ class RelationshipDeleteAllQuery(Query):
     type = QueryType.WRITE
     insert_return = False
 
-    def __init__(self, node_id: str, **kwargs):
+    def __init__(self, node_id: str, **kwargs) -> None:
         self.node_id = node_id
         super().__init__(**kwargs)
 
@@ -1313,51 +1367,54 @@ class RelationshipDeleteAllQuery(Query):
             "peer_node_metadata_update": peer_node_metadata_update,
         }
         self.add_to_query(query)
+        self.return_labels = ["uuid", "kind", "rel_identifier", "rel_direction"]
+
+    def get_data(self) -> list[RelationshipDeleteAllQueryResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of RelationshipDeleteAllQueryResult containing deleted relationship info.
+        """
+        return [RelationshipDeleteAllQueryResult.from_db(result) for result in self.get_results()]
 
     def get_deleted_relationships_changelog(
         self, node_schema: NodeSchema
     ) -> list[RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog]:
-        rel_identifier_to_changelog_mapper = {}
+        rel_identifier_to_changelog_mapper: dict[str, ChangelogRelationshipMapper] = {}
 
-        for result in self.get_results():
-            peer_uuid = result.data["uuid"]
-            if peer_uuid == self.node_id:
+        for item in self.get_data():
+            if item.uuid == self.node_id:
                 continue
 
-            rel_identifier = result.data["rel_identifier"]
-            kind = result.data["kind"]
             deleted_rel_schemas = [
-                rel_schema for rel_schema in node_schema.relationships if rel_schema.identifier == rel_identifier
+                rel_schema for rel_schema in node_schema.relationships if rel_schema.identifier == item.rel_identifier
             ]
 
             if len(deleted_rel_schemas) == 0:
                 continue  # TODO Unidirectional relationship changelog should be handled, cf IFC-1319.
 
             if len(deleted_rel_schemas) > 2:
-                log.error(f"Duplicated relationship schema with identifier {rel_identifier}")
+                log.error(f"Duplicated relationship schema with identifier {item.rel_identifier}")
                 continue
 
             if len(deleted_rel_schemas) == 2:
                 # Hierarchical schema nodes have 2 relationships with `parent_child` identifiers,
                 # which are differentiated by their direction within the database.
-                # assert rel_identifier != PARENT_CHILD_IDENTIFIER
-
-                rel_direction = result.data["rel_direction"]
                 deleted_rel_schema = (
                     deleted_rel_schemas[0]
-                    if deleted_rel_schemas[0].direction.value == rel_direction
+                    if deleted_rel_schemas[0].direction.value == item.rel_direction
                     else deleted_rel_schemas[1]
                 )
             else:
                 deleted_rel_schema = deleted_rel_schemas[0]
 
             try:
-                changelog_mapper = rel_identifier_to_changelog_mapper[rel_identifier]
+                changelog_mapper = rel_identifier_to_changelog_mapper[item.rel_identifier]
             except KeyError:
                 changelog_mapper = ChangelogRelationshipMapper(schema=deleted_rel_schema)
-                rel_identifier_to_changelog_mapper[rel_identifier] = changelog_mapper
+                rel_identifier_to_changelog_mapper[item.rel_identifier] = changelog_mapper
 
-            changelog_mapper.delete_relationship(peer_id=peer_uuid, peer_kind=kind, rel_schema=deleted_rel_schema)
+            changelog_mapper.delete_relationship(peer_id=item.uuid, peer_kind=item.kind, rel_schema=deleted_rel_schema)
 
         return [changelog_mapper.changelog for changelog_mapper in rel_identifier_to_changelog_mapper.values()]
 
@@ -1371,7 +1428,7 @@ class GetAllPeersIds(Query):
     type: QueryType = QueryType.READ
     insert_return = False
 
-    def __init__(self, node_id: str, exclude_identifiers: list[str], **kwargs):
+    def __init__(self, node_id: str, exclude_identifiers: list[str], **kwargs) -> None:
         self.node_id = node_id
         self.exclude_identifiers = exclude_identifiers
         super().__init__(**kwargs)

infrahub/core/query/resource_manager.py

@@ -1,24 +1,74 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Generator
 
-from pydantic import BaseModel, ConfigDict
-
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind, RelationshipStatus
-from infrahub.core.query import Query, QueryType
+from infrahub.core.query import Query, QueryResult, QueryType
 
 if TYPE_CHECKING:
     from infrahub.core.protocols import CoreNumberPool
     from infrahub.database import InfrahubDatabase
 
 
-class NumberPoolIdentifierData(BaseModel):
-    model_config = ConfigDict(frozen=True)
+@dataclass(frozen=True)
+class NumberPoolIdentifierData:
+    """Result containing a pool reservation value and its identifier."""
 
     value: int
     identifier: str
 
+    @classmethod
+    def from_db(cls, result: QueryResult) -> NumberPoolIdentifierData:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            value=result.get_as_type("value", return_type=int),
+            identifier=result.get_as_type("identifier", return_type=str),
+        )
+
+
+@dataclass(frozen=True)
+class PoolIdentifierResult:
+    """Result from pool identifier queries containing allocation and identifier data."""
+
+    allocated_uuid: str
+    """UUID of the allocated resource (address or prefix)."""
+
+    identifier: str
+    """Identifier used for the reservation."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> PoolIdentifierResult:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            allocated_uuid=result.get_as_type("allocated_uuid", str),
+            identifier=result.get_as_type("identifier", str),
+        )
+
+
+@dataclass(frozen=True)
+class NumberPoolAllocatedResult:
+    """Result from NumberPoolGetAllocated containing allocated number info."""
+
+    id: str
+    """UUID of the node with the allocated number."""
+
+    branch: str
+    """Branch where the allocation exists."""
+
+    value: int
+    """The allocated number value."""
+
+    @classmethod
+    def from_db(cls, result: QueryResult) -> NumberPoolAllocatedResult:
+        """Convert raw QueryResult to typed dataclass."""
+        return cls(
+            id=result.get_as_type("id", str),
+            branch=result.get_as_type("branch", str),
+            value=result.get_as_type("value", int),
+        )
+
 
 class IPAddressPoolGetIdentifiers(Query):
     name = "ipaddresspool_get_identifiers"
@@ -44,7 +94,15 @@ class IPAddressPoolGetIdentifiers(Query):
         WHERE allocated.uuid in $addresses
         """ % {"ipaddress_pool": InfrahubKind.IPADDRESSPOOL}
         self.add_to_query(query)
-        self.return_labels = ["allocated", "reservation"]
+        self.return_labels = ["allocated.uuid AS allocated_uuid", "reservation.identifier AS identifier"]
+
+    def get_data(self) -> list[PoolIdentifierResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of PoolIdentifierResult containing allocation and identifier data.
+        """
+        return [PoolIdentifierResult.from_db(result) for result in self.get_results()]
 
 
 class IPAddressPoolGetReserved(Query):
@@ -159,6 +217,14 @@ class NumberPoolGetAllocated(Query):
         self.return_labels = ["n.uuid as id", "hv.branch as branch", "av.value as value"]
         self.order_by = ["av.value"]
 
+    def get_data(self) -> list[NumberPoolAllocatedResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of NumberPoolAllocatedResult containing allocated number info.
+        """
+        return [NumberPoolAllocatedResult.from_db(result) for result in self.get_results()]
+
 
 class NumberPoolGetReserved(Query):
     name = "numberpool_get_reserved"
@@ -205,17 +271,31 @@ class NumberPoolGetReserved(Query):
         self.return_labels = ["reservation.value AS value", "r.identifier AS identifier"]
 
     def get_reservation(self) -> int | None:
+        """Return the reserved value for a single identifier.
+
+        Returns:
+            The reserved integer value, or None if no reservation exists.
+        """
         result = self.get_result()
         if result:
             return result.get_as_optional_type("value", return_type=int)
         return None
 
+    def get_data(self) -> list[NumberPoolIdentifierData]:
+        """Return all reservations as typed dataclass instances.
+
+        Returns:
+            List of NumberPoolIdentifierData containing value and identifier.
+        """
+        return [NumberPoolIdentifierData.from_db(result) for result in self.get_results()]
+
     def get_reservations(self) -> Generator[NumberPoolIdentifierData]:
-        for result in self.results:
-            yield NumberPoolIdentifierData.model_construct(
-                value=result.get_as_type("value", return_type=int),
-                identifier=result.get_as_type("identifier", return_type=str),
-            )
+        """Yield reservations as typed dataclass instances.
+
+        Yields:
+            NumberPoolIdentifierData for each reservation.
+        """
+        yield from self.get_data()
 
 
 class PoolChangeReserved(Query):
@@ -282,7 +362,6 @@ This will be especially important as we want to support upsert with NumberPool
 class NumberPoolGetUsed(Query):
     name = "number_pool_get_used"
     type = QueryType.READ
-    return_model = NumberPoolIdentifierData
 
     def __init__(
         self,
@@ -331,11 +410,13 @@ class NumberPoolGetUsed(Query):
         self.order_by = ["value"]
 
     def iter_results(self) -> Generator[NumberPoolIdentifierData]:
-        for result in self.results:
-            yield self.return_model.model_construct(
-                value=result.get_as_type("value", return_type=int),
-                identifier=result.get_as_type("identifier", return_type=str),
-            )
+        """Yield used pool values as typed dataclass instances.
+
+        Yields:
+            NumberPoolIdentifierData for each used value in the pool.
+        """
+        for result in self.get_results():
+            yield NumberPoolIdentifierData.from_db(result)
 
 
 class NumberPoolSetReserved(Query):
@@ -405,7 +486,15 @@ class PrefixPoolGetIdentifiers(Query):
         WHERE allocated.uuid in $prefixes
         """ % {"ipaddress_pool": InfrahubKind.IPPREFIXPOOL}
         self.add_to_query(query)
-        self.return_labels = ["allocated", "reservation"]
+        self.return_labels = ["allocated.uuid AS allocated_uuid", "reservation.identifier AS identifier"]
+
+    def get_data(self) -> list[PoolIdentifierResult]:
+        """Return results as typed dataclass instances.
+
+        Returns:
+            List of PoolIdentifierResult containing allocation and identifier data.
+        """
+        return [PoolIdentifierResult.from_db(result) for result in self.get_results()]
 
 
 class PrefixPoolGetReserved(Query):

infrahub/core/relationship/constraints/count.py

@@ -22,7 +22,7 @@ class NodeToValidate:
 
 
 class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_kind.py

@@ -23,7 +23,7 @@ class NodeToValidate:
 
 
 class RelationshipPeerKindConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_parent.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 
 class RelationshipPeerParentConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_relatives.py

@@ -25,7 +25,7 @@ class NodeToValidate:
 
 
 class RelationshipPeerRelativesConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/profiles_kind.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 
 
 class RelationshipProfilesKindConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)

infrahub/core/relationship/constraints/profiles_removal.py

@@ -28,7 +28,7 @@ class RelationshipProfileRemovalConstraint(RelationshipManagerConstraintInterfac
     In both cases, it will perform checks only if peers are being removed from the relationship being changed.
     """
 
-    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)

infrahub/core/relationship/model.py

@@ -1181,6 +1181,7 @@ class RelationshipManager:
         db: InfrahubDatabase,
         process_delete: bool = True,
         user_id: str = SYSTEM_USER_ID,
+        at: Timestamp | None = None,
     ) -> bool:
         """Replace and Update the list of relationships with this one."""
         if not isinstance(data, list):
@@ -1189,6 +1190,7 @@ class RelationshipManager:
             list_data = data
 
         await self._validate_hierarchy()
+        update_at = Timestamp(at)
 
         # Reset the list of relationship and save the previous one to see if we can reuse some
         previous_relationships = {rel.peer_id: rel for rel in await self.get_relationships(db=db) if rel.peer_id}
@@ -1211,7 +1213,7 @@ class RelationshipManager:
                 if previous_relationships:
                     if process_delete:
                         for rel in previous_relationships.values():
-                            await rel.delete(db=db, user_id=user_id)
+                            await rel.delete(db=db, at=update_at, user_id=user_id)
                     changed = True
                 continue
 
@@ -1231,7 +1233,11 @@ class RelationshipManager:
             # If the item is not present in the previous list of relationship, we create a new one.
             self._relationships.append(
                 await self.rel_class(
-                    schema=self.schema, branch=self.branch, source_kind=self.node.get_kind(), at=self.at, node=self.node
+                    schema=self.schema,
+                    branch=self.branch,
+                    source_kind=self.node.get_kind(),
+                    at=update_at,
+                    node=self.node,
                 ).new(db=db, data=item)
             )
             changed = True

infrahub/core/schema/attribute_parameters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Self
+from typing import Any, Self
 
 from pydantic import ConfigDict, Field, model_validator
 
@@ -24,6 +24,33 @@ def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParamete
 class AttributeParameters(HashableModel):
     model_config = ConfigDict(extra="forbid")
 
+    @classmethod
+    def convert_from(cls, source: AttributeParameters) -> Self:
+        """Convert from another AttributeParameters subclass.
+
+        Args:
+            source: The source AttributeParameters instance to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        source_data = source.model_dump()
+        return cls.convert_from_dict(source_data=source_data)
+
+    @classmethod
+    def convert_from_dict(cls, source_data: dict[str, Any]) -> Self:
+        """Convert from a dictionary to the target class.
+
+        Args:
+            source_data: The source dictionary to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        target_fields = set(cls.model_fields.keys())
+        filtered_data = {k: v for k, v in source_data.items() if k in target_fields}
+        return cls(**filtered_data)
+
 
 class TextAttributeParameters(AttributeParameters):
     regex: str | None = Field(

infrahub/core/schema/attribute_schema.py

@@ -114,13 +114,20 @@ class AttributeSchema(GeneratedAttributeSchema):
     @field_validator("parameters", mode="before")
     @classmethod
     def set_parameters_type(cls, value: Any, info: ValidationInfo) -> Any:
-        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
+        """Override parameters class if using base AttributeParameters class and should be using a subclass.
+
+        This validator handles parameter type conversion when an attribute's kind changes.
+        Fields from the source that don't exist in the target are silently dropped.
+        Fields with the same name in both classes are preserved.
+        """
         kind = info.data["kind"]
         expected_parameters_class = get_attribute_parameters_class_for_kind(kind=kind)
         if value is None:
             return expected_parameters_class()
         if not isinstance(value, expected_parameters_class) and isinstance(value, AttributeParameters):
-            return expected_parameters_class(**value.model_dump())
+            return expected_parameters_class.convert_from(value)
+        if isinstance(value, dict):
+            return expected_parameters_class.convert_from_dict(source_data=value)
         return value
 
     @model_validator(mode="after")
@@ -238,19 +245,6 @@ class TextAttributeSchema(AttributeSchema):
         json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
     )
 
-    @model_validator(mode="after")
-    def reconcile_parameters(self) -> Self:
-        if self.regex != self.parameters.regex:
-            final_regex = self.parameters.regex if self.parameters.regex is not None else self.regex
-            self.regex = self.parameters.regex = final_regex
-        if self.min_length != self.parameters.min_length:
-            final_min_length = self.parameters.min_length if self.parameters.min_length is not None else self.min_length
-            self.min_length = self.parameters.min_length = final_min_length
-        if self.max_length != self.parameters.max_length:
-            final_max_length = self.parameters.max_length if self.parameters.max_length is not None else self.max_length
-            self.max_length = self.parameters.max_length = final_max_length
-        return self
-
     def get_regex(self) -> str | None:
         return self.parameters.regex
 

infrahub/core/schema/basenode_schema.py

@@ -263,6 +263,9 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     ) -> AttributeSchema | RelationshipSchema | None: ...
 
     def get_field(self, name: str, raise_on_error: bool = True) -> AttributeSchema | RelationshipSchema | None:
+        if name in NODE_PROPERTY_ATTRIBUTES:
+            return self.get_attribute(name=name)
+
         if field := self.get_attribute_or_none(name=name):
             return field
 

infrahub/core/schema/definitions/core/__init__.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, TypedDict
 
 from infrahub.actions.schema import (
     core_action,
@@ -93,7 +93,13 @@ from .template import core_object_component_template, core_object_template
 from .transform import core_transform, core_transform_jinja2, core_transform_python
 from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
 
-core_models_mixed: dict[str, list] = {
+
+class CoreModelsMixedType(TypedDict):
+    generics: list[GenericSchema]
+    nodes: list[NodeSchema]
+
+
+core_models_mixed: CoreModelsMixedType = {
     "generics": [
         core_action,
         core_trigger_rule,