infrahub-server 1.6.3__py3-none-any.whl → 1.7.0__py3-none-any.whl

infrahub/core/schema/manager.py

@@ -6,6 +6,7 @@ from cachetools import LRUCache
 from infrahub_sdk.schema import BranchSchema as SDKBranchSchema
 
 from infrahub import lock
+from infrahub.core.constants import SYSTEM_USER_ID, MetadataOptions
 from infrahub.core.manager import NodeManager
 from infrahub.core.models import (
     HashableModelDiff,
@@ -178,15 +179,18 @@ class SchemaManager(NodeManager):
         diff: SchemaDiff | None = None,
         limit: list[str] | None = None,
         update_db: bool = True,
+        user_id: str = SYSTEM_USER_ID,
     ) -> None:
         branch = await registry.get_branch(branch=branch, db=db)
 
         updated_schema = None
         if update_db:
             if diff:
-                schema_diff = await self.update_schema_to_db(schema=schema, db=db, branch=branch, diff=diff)
+                schema_diff = await self.update_schema_to_db(
+                    schema=schema, db=db, branch=branch, diff=diff, user_id=user_id
+                )
             else:
-                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit)
+                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, user_id=user_id)
                 # After updating the schema into the db
                 # we need to pull a fresh version because some default value are managed/generated within the node object
                 schema_diff = None
@@ -216,6 +220,7 @@ class SchemaManager(NodeManager):
         schema: SchemaBranch,
         db: InfrahubDatabase,
         diff: SchemaDiff,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> SchemaBranchDiff:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
@@ -226,7 +231,7 @@ class SchemaManager(NodeManager):
         added_generics = []
         for item_kind in diff.added.keys():
             item = schema.get(name=item_kind, duplicate=False)
-            node = await self.load_node_to_db(node=item, branch=branch, db=db)
+            node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 added_nodes.append(item_kind)
@@ -238,9 +243,11 @@ class SchemaManager(NodeManager):
         for item_kind, item_diff in diff.changed.items():
             item = schema.get(name=item_kind, duplicate=False)
             if item_diff:
-                node = await self.update_node_in_db_based_on_diff(node=item, branch=branch, db=db, diff=item_diff)
+                node = await self.update_node_in_db_based_on_diff(
+                    node=item, branch=branch, db=db, diff=item_diff, user_id=user_id
+                )
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 changed_nodes.append(item_kind)
@@ -251,7 +258,7 @@ class SchemaManager(NodeManager):
         removed_generics = []
         for item_kind in diff.removed.keys():
             item = schema.get(name=item_kind, duplicate=False)
-            node = await self.delete_node_in_db(node=item, branch=branch, db=db)
+            node = await self.delete_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
             schema.delete(name=item_kind)
             if item.is_node_schema:
                 removed_nodes.append(item_kind)
@@ -273,6 +280,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         branch: Branch | str | None = None,
         limit: list[str] | None = None,
+        user_id: str = SYSTEM_USER_ID,
     ) -> None:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
 
@@ -283,16 +291,17 @@ class SchemaManager(NodeManager):
                 continue
             item = schema.get(name=item_kind, duplicate=False)
             if not item.id:
-                node = await self.load_node_to_db(node=item, branch=branch, db=db)
+                node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
 
     async def load_node_to_db(
         self,
         node: NodeSchema | GenericSchema,
         db: InfrahubDatabase,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Load a Node with its attributes and its relationships to the database."""
@@ -313,7 +322,7 @@ class SchemaManager(NodeManager):
         schema_dict = node.model_dump(exclude={"id", "state", "filters", "relationships", "attributes"})
         obj = await Node.init(schema=node_schema, branch=branch, db=db)
         await obj.new(**schema_dict, db=db)
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
         new_node.id = obj.id
 
         # Then create the Attributes and the relationships
@@ -324,7 +333,7 @@ class SchemaManager(NodeManager):
             for item in node.attributes:
                 if item.inherited is False:
                     new_attr = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db
+                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
                     )
                 else:
                     new_attr = item.duplicate()
@@ -333,7 +342,7 @@ class SchemaManager(NodeManager):
             for item in node.relationships:
                 if item.inherited is False:
                     new_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db
+                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
                     )
                 else:
                     new_rel = item.duplicate()
@@ -347,6 +356,7 @@ class SchemaManager(NodeManager):
         self,
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database."""
@@ -374,7 +384,7 @@ class SchemaManager(NodeManager):
         await obj.relationships.update(
             db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"]
         )
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
 
         # Then Update the Attributes and the relationships
 
@@ -382,25 +392,24 @@ class SchemaManager(NodeManager):
             ids=[item.id for item in node.local_attributes + node.local_relationships if item.id],
             db=db,
             branch=branch,
-            include_owner=True,
-            include_source=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
 
         for item in node.local_attributes:
             if item.id and item.id in items:
-                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db)
+                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
             elif not item.id:
                 new_attr = await self.create_attribute_in_db(
-                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj
+                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                 )
                 new_node.attributes.append(new_attr)
 
         for item in node.local_relationships:
             if item.id and item.id in items:
-                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db)
+                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
             elif not item.id:
                 new_rel = await self.create_relationship_in_db(
-                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj
+                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                 )
                 new_node.relationships.append(new_rel)
 
@@ -413,6 +422,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         diff: HashableModelDiff,
         node: NodeSchema | GenericSchema,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database based on a HashableModelDiff."""
@@ -466,8 +476,7 @@ class SchemaManager(NodeManager):
                 ids=list(item_ids),
                 db=db,
                 branch=branch,
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
         if missing_field_names:
             missing_attrs = await self.query(
@@ -475,16 +484,14 @@ class SchemaManager(NodeManager):
                 branch=branch,
                 schema=attribute_schema,
                 filters={"name__values": missing_field_names, "node__id": node.id},
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
             missing_rels = await self.query(
                 db=db,
                 branch=branch,
                 schema=relationship_schema,
                 filters={"name__values": missing_field_names, "node__id": node.id},
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
             items.update({field.id: field for field in missing_attrs + missing_rels})
 
@@ -494,21 +501,21 @@ class SchemaManager(NodeManager):
         if diff_relationships:
             await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id])
 
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
 
         if diff_attributes:
             for item in node.local_attributes:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
                 if item.name in diff_attributes.added or (item.name in diff_attributes.changed and item.id is None):
                     created_item = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj
+                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                     )
                     new_attr = new_node.get_attribute(name=item.name)
                     new_attr.id = created_item.id
                 elif item.name in diff_attributes.changed and item.id and item.id in items:
-                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db)
+                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
                 elif item.name in diff_attributes.removed and item.id and item.id in items:
-                    await items[item.id].delete(db=db)
+                    await items[item.id].delete(db=db, user_id=user_id)
                 elif (
                     (item.name in diff_attributes.removed or item.name in diff_attributes.changed)
                     and item.id
@@ -523,14 +530,14 @@ class SchemaManager(NodeManager):
                     item.name in diff_relationships.changed and item.id is None
                 ):
                     created_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj
+                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
                     )
                     new_rel = new_node.get_relationship(name=item.name)
                     new_rel.id = created_rel.id
                 elif item.name in diff_relationships.changed and item.id and item.id in items:
-                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db)
+                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
                 elif item.name in diff_relationships.removed and item.id and item.id in items:
-                    await items[item.id].delete(db=db)
+                    await items[item.id].delete(db=db, user_id=user_id)
                 elif (
                     (item.name in diff_relationships.removed or item.name in diff_relationships.changed)
                     and item.id
@@ -548,7 +555,7 @@ class SchemaManager(NodeManager):
         if field_names_to_remove:
             for field_schema in items.values():
                 if field_schema.name.value in field_names_to_remove:
-                    await field_schema.delete(db=db)
+                    await field_schema.delete(db=db, user_id=user_id)
 
         # Save back the node with the (potentially) newly created IDs in the SchemaManager
         self.set(name=new_node.kind, schema=new_node, branch=branch.name)
@@ -558,6 +565,7 @@ class SchemaManager(NodeManager):
         self,
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
+        user_id: str,
         branch: Branch | str | None = None,
     ) -> None:
         """Delete the node with its attributes and relationships."""
@@ -573,47 +581,59 @@ class SchemaManager(NodeManager):
 
         # First delete the attributes and the relationships
         for attr_schema_node in (await obj.attributes.get_peers(db=db)).values():
-            await attr_schema_node.delete(db=db)
+            await attr_schema_node.delete(db=db, user_id=user_id)
         for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
-            await rel_schema_node.delete(db=db)
+            await rel_schema_node.delete(db=db, user_id=user_id)
 
-        await obj.delete(db=db)
+        await obj.delete(db=db, user_id=user_id)
 
     @staticmethod
     async def create_attribute_in_db(
-        schema: NodeSchema, item: AttributeSchema, branch: Branch, parent: Node, db: InfrahubDatabase
+        schema: NodeSchema,
+        item: AttributeSchema,
+        branch: Branch,
+        parent: Node,
+        db: InfrahubDatabase,
+        user_id: str,
     ) -> AttributeSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.to_node(), node=parent, db=db)
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
-    async def update_attribute_in_db(item: AttributeSchema, attr: Node, db: InfrahubDatabase) -> None:
+    async def update_attribute_in_db(item: AttributeSchema, attr: Node, db: InfrahubDatabase, user_id: str) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(attr, key).value = value
-        await attr.save(db=db)
+        await attr.save(db=db, user_id=user_id)
 
     @staticmethod
     async def create_relationship_in_db(
-        schema: NodeSchema, item: RelationshipSchema, branch: Branch, parent: Node, db: InfrahubDatabase
+        schema: NodeSchema,
+        item: RelationshipSchema,
+        branch: Branch,
+        parent: Node,
+        db: InfrahubDatabase,
+        user_id: str,
     ) -> RelationshipSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.model_dump(exclude={"id", "state", "filters"}), node=parent, db=db)
-        await obj.save(db=db)
+        await obj.save(db=db, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
-    async def update_relationship_in_db(item: RelationshipSchema, rel: Node, db: InfrahubDatabase) -> None:
+    async def update_relationship_in_db(
+        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, user_id: str
+    ) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(rel, key).value = value
-        await rel.save(db=db)
+        await rel.save(db=db, user_id=user_id)
 
     async def load_schema(
         self,

infrahub/core/schema/relationship_schema.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 from pydantic import BaseModel
 
 from infrahub import config
-from infrahub.core.constants import RelationshipDirection
+from infrahub.core.constants import RelationshipDirection, RelationshipKind
 from infrahub.core.query import QueryNode, QueryRel, QueryRelDirection
 from infrahub.core.relationship import Relationship
 from infrahub.exceptions import InitializationError
@@ -36,6 +36,10 @@ class RelationshipSchema(GeneratedRelationshipSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    @property
+    def support_profiles(self) -> bool:
+        return self.read_only is False and self.kind in {RelationshipKind.GENERIC, RelationshipKind.ATTRIBUTE}
+
     def to_dict(self) -> dict:
         data = self.model_dump(exclude_unset=True, exclude_none=True)
         for field_name, value in data.items():
@@ -75,7 +79,7 @@ class RelationshipSchema(GeneratedRelationshipSchema):
 
     def update_from_generic(self, other: RelationshipSchema) -> None:
         fields_to_exclude = ("id", "order_weight", "branch", "inherited", "filters")
-        for name in self.model_fields:
+        for name in self.__class__.model_fields:
             if name in fields_to_exclude:
                 continue
             if getattr(self, name) != getattr(other, name):

infrahub/core/schema/schema_branch.py

@@ -93,7 +93,7 @@ class SchemaBranch:
         computed_attributes: ComputedAttributes | None = None,
         display_labels: DisplayLabels | None = None,
         hfids: HFIDs | None = None,
-    ):
+    ) -> None:
         self._cache: dict[str, NodeSchema | GenericSchema] = cache
         self.name: str | None = name
         self.nodes: dict[str, str] = {}
@@ -236,8 +236,8 @@ class SchemaBranch:
             if diff_node.has_diff:
                 schema_diff.changed[key] = diff_node
 
-        reversed_map_local = dict(map(reversed, local_kind_id_map.items()))
-        reversed_map_other = dict(map(reversed, other_kind_id_map.items()))
+        reversed_map_local: dict[str | None, str] = {v: k for k, v in local_kind_id_map.items()}
+        reversed_map_other: dict[str | None, str] = {v: k for k, v in other_kind_id_map.items()}
 
         for shared_id in shared_ids:
             local_node = self.get(name=reversed_map_local[shared_id], duplicate=False)
@@ -2225,6 +2225,45 @@ class SchemaBranch:
 
             self.set(name=node_name, schema=node)
 
+    def add_relationships_to_profile(self, profile: ProfileSchema, node: NodeSchema | GenericSchema) -> None:
+        # Remove previous relationships to account for new ones
+        profile.relationships = [r for r in profile.relationships if r.kind == RelationshipKind.PROFILE]
+
+        for relationship in node.relationships:
+            if not relationship.support_profiles:
+                continue
+
+            # Ignore relationship if it is part of a uniqueness constraint
+            ignore_relationship = False
+            for constraint in node.uniqueness_constraints or []:
+                if relationship.name in constraint:
+                    ignore_relationship = True
+                    break
+            if ignore_relationship:
+                continue
+
+            identifier = (
+                f"profile_{relationship.identifier}"
+                if relationship.identifier
+                else self._generate_identifier_string(profile.kind, relationship.peer)
+            )
+
+            profile.relationships.append(
+                RelationshipSchema(
+                    name=relationship.name,
+                    peer=relationship.peer,
+                    kind=relationship.kind,
+                    cardinality=relationship.cardinality,
+                    direction=relationship.direction,
+                    branch=relationship.branch,
+                    identifier=identifier,
+                    min_count=relationship.min_count,
+                    max_count=relationship.max_count,
+                    label=relationship.label,
+                    inherited=False,
+                )
+            )
+
     def manage_profile_schemas(self) -> None:
         if not self.has(name=InfrahubKind.PROFILE):
             # TODO: This logic is actually only for testing purposes as since 1.0.9 CoreProfile is loaded in db.
@@ -2244,6 +2283,7 @@ class SchemaBranch:
                 continue
 
             profile = self.generate_profile_from_node(node=node)
+            self.add_relationships_to_profile(profile=profile, node=node)
             self.set(name=profile.kind, schema=profile)
             profile_schema_kinds.add(profile.kind)
 
@@ -2318,13 +2358,13 @@ class SchemaBranch:
         core_name_attr = core_profile_schema.get_attribute(name="profile_name")
         name_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_name_attr.kind)
         profile_name_attr = name_attr_schema_class(
-            **core_name_attr.model_dump(exclude=["id", "inherited"]),
+            **core_name_attr.model_dump(exclude={"id", "inherited"}),
         )
         profile_name_attr.branch = node.branch
         core_priority_attr = core_profile_schema.get_attribute(name="profile_priority")
         priority_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_priority_attr.kind)
         profile_priority_attr = priority_attr_schema_class(
-            **core_priority_attr.model_dump(exclude=["id", "inherited"]),
+            **core_priority_attr.model_dump(exclude={"id", "inherited"}),
         )
         profile_priority_attr.branch = node.branch
         profile = ProfileSchema(
@@ -2369,7 +2409,7 @@ class SchemaBranch:
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
                 optional=True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "default_value", "inherited"]),
+                **node_attr.model_dump(exclude={"id", "unique", "optional", "read_only", "default_value", "inherited"}),
             )
             profile.attributes.append(attr)
 
@@ -2513,9 +2553,7 @@ class SchemaBranch:
         )
         core_name_attr = core_template_schema.get_attribute(name=OBJECT_TEMPLATE_NAME_ATTR)
         name_attr_schema_class = get_attribute_schema_class_for_kind(kind=core_name_attr.kind)
-        template_name_attr = name_attr_schema_class(
-            **core_name_attr.model_dump(exclude=["id", "inherited"]),
-        )
+        template_name_attr = name_attr_schema_class(**core_name_attr.model_dump(exclude={"id", "inherited"}))
         template_name_attr.branch = node.branch
 
         template: TemplateSchema | GenericSchema
@@ -2574,7 +2612,7 @@ class SchemaBranch:
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "order_weight"]),
+                **node_attr.model_dump(exclude={"id", "unique", "optional", "read_only", "order_weight"}),
             )
             template.attributes.append(attr)
 

infrahub/core/task/task.py

@@ -1,9 +1,11 @@
+# This entire file and possibly everything in this module should be deleted. - Patrick (2025-12-11)
+
 from typing import Any
 
 from pydantic import ConfigDict, Field
 
 from infrahub.core.constants import TaskConclusion
-from infrahub.core.node.standard import StandardNode
+from infrahub.core.node.standard import StandardNode, StandardNodeQueryFields
 from infrahub.core.protocols import CoreNode
 from infrahub.core.query.standard_node import StandardNodeQuery
 from infrahub.core.query.task import TaskNodeCreateQuery, TaskNodeQuery, TaskNodeQueryWithLogs
@@ -70,7 +72,7 @@ class Task(StandardNode):
                 logs = [
                     {
                         "node": await TaskLog.from_db(result, extras={"task_id": task_result.get("uuid")}).to_graphql(
-                            fields=log_fields
+                            fields=StandardNodeQueryFields(node=log_fields)
                         )
                     }
                     for result in logs_results

infrahub/core/utils.py

@@ -62,28 +62,6 @@ async def delete_all_relationships_for_branch(branch_name: str, db: InfrahubData
     await db.execute_query(query=query, params=params, name="delete_all_relationships_for_branch")
 
 
-async def update_relationships_to(
-    ids: list[str], db: InfrahubDatabase, to: Timestamp | None = None
-) -> list[Record] | None:
-    """Update the "to" field on one or multiple relationships."""
-    if not ids:
-        return None
-
-    to = Timestamp(to)
-
-    query = """
-    MATCH ()-[r]->()
-    WHERE %(id_func)s(r) IN $ids
-    AND r.to IS NULL
-    SET r.to = $to
-    RETURN %(id_func)s(r)
-    """ % {"id_func": db.get_id_function_name()}
-
-    params = {"to": to.to_string(), "ids": [db.to_database_id(_id) for _id in ids]}
-
-    return await db.execute_query(query=query, params=params, name="update_relationships_to")
-
-
 async def get_paths_between_nodes(
     db: InfrahubDatabase,
     source_id: str,
@@ -237,7 +215,7 @@ def props(x: Any) -> dict[str, Any]:
 
 
 class SubclassWithMeta_Meta(type):
-    _meta = None
+    _meta: Any = None
 
     def __str__(cls) -> str:
         if cls._meta:
@@ -251,7 +229,7 @@ class SubclassWithMeta_Meta(type):
 class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
     """This class improves __init_subclass__ to receive automatically the options from meta"""
 
-    def __init_subclass__(cls, **meta_options: dict[str, Any]) -> None:
+    def __init_subclass__(cls, **meta_options: Any) -> None:
         """This method just terminates the super() chain"""
         _Meta = getattr(cls, "Meta", None)
         _meta_props = {}
@@ -276,5 +254,5 @@ class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
                 super_class.__init_subclass_with_meta__(**options)
 
     @classmethod
-    def __init_subclass_with_meta__(cls, **meta_options: dict[str, Any]) -> None:
+    def __init_subclass_with_meta__(cls, **meta_options: Any) -> None:
         """This method just terminates the super() chain"""

infrahub/core/validators/aggregated_checker.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 class AggregatedConstraintChecker:
     def __init__(
         self, constraints: list[ConstraintCheckerInterface], db: InfrahubDatabase, branch: Branch | None = None
-    ):
+    ) -> None:
         self.constraints = constraints
         self.db = db
         self.branch = branch

infrahub/core/validators/attribute/choices.py

@@ -84,7 +84,7 @@ class AttributeChoicesUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeChoicesChecker(ConstraintCheckerInterface):
     query_classes = [AttributeChoicesUpdateValidatorQuery]
 
-    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/validators/attribute/enum.py

@@ -72,7 +72,7 @@ class AttributeEnumUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeEnumChecker(ConstraintCheckerInterface):
     query_classes = [AttributeEnumUpdateValidatorQuery]
 
-    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/validators/attribute/kind.py

@@ -92,7 +92,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeKindChecker(ConstraintCheckerInterface):
     query_classes = [AttributeKindUpdateValidatorQuery]
 
-    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/validators/attribute/length.py

@@ -69,7 +69,7 @@ class AttributeLengthUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeLengthChecker(ConstraintCheckerInterface):
     query_classes = [AttributeLengthUpdateValidatorQuery]
 
-    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/validators/attribute/min_max.py

@@ -79,7 +79,7 @@ class AttributeNumberUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeNumberChecker(ConstraintCheckerInterface):
     query_classes = [AttributeNumberUpdateValidatorQuery]
 
-    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/validators/attribute/number_pool.py

@@ -74,7 +74,7 @@ class AttributeNumberPoolUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeNumberPoolChecker(ConstraintCheckerInterface):
     query_classes = [AttributeNumberPoolUpdateValidatorQuery]
 
-    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/validators/attribute/optional.py

@@ -64,7 +64,7 @@ class AttributeOptionalUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeOptionalChecker(ConstraintCheckerInterface):
     query_classes = [AttributeOptionalUpdateValidatorQuery]
 
-    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/validators/attribute/regex.py

@@ -69,7 +69,7 @@ class AttributeRegexUpdateValidatorQuery(AttributeSchemaValidatorQuery):
 class AttributeRegexChecker(ConstraintCheckerInterface):
     query_classes = [AttributeRegexUpdateValidatorQuery]
 
-    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