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

infrahub/core/schema/manager.py

@@ -25,6 +25,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import parse_node_kind
 from infrahub.exceptions import SchemaNotFoundError
 from infrahub.log import get_logger
@@ -36,7 +37,6 @@ log = get_logger()
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
-    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -179,18 +179,20 @@ class SchemaManager(NodeManager):
         diff: SchemaDiff | None = None,
         limit: list[str] | None = None,
         update_db: bool = True,
+        at: Timestamp | None = None,
         user_id: str = SYSTEM_USER_ID,
     ) -> None:
         branch = await registry.get_branch(branch=branch, db=db)
+        at = Timestamp(at)
 
         updated_schema = None
         if update_db:
             if diff:
                 schema_diff = await self.update_schema_to_db(
-                    schema=schema, db=db, branch=branch, diff=diff, user_id=user_id
+                    schema=schema, db=db, branch=branch, diff=diff, at=at, user_id=user_id
                 )
             else:
-                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, user_id=user_id)
+                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, at=at, 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
@@ -201,7 +203,7 @@ class SchemaManager(NodeManager):
                     )
 
             updated_schema = await self.load_schema_from_db(
-                db=db, branch=branch, schema=schema, schema_diff=schema_diff
+                db=db, branch=branch, schema=schema, schema_diff=schema_diff, at=at
             )
 
         self.set_schema_branch(name=branch.name, schema=updated_schema or schema)
@@ -221,6 +223,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         diff: SchemaDiff,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> SchemaBranchDiff:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
@@ -231,7 +234,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, user_id=user_id)
+            node = await self.load_node_to_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 added_nodes.append(item_kind)
@@ -244,10 +247,10 @@ class SchemaManager(NodeManager):
             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, user_id=user_id
+                    node=item, branch=branch, db=db, diff=item_diff, at=at, user_id=user_id
                 )
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 changed_nodes.append(item_kind)
@@ -258,7 +261,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, user_id=user_id)
+            node = await self.delete_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.delete(name=item_kind)
             if item.is_node_schema:
                 removed_nodes.append(item_kind)
@@ -281,9 +284,10 @@ class SchemaManager(NodeManager):
         branch: Branch | str | None = None,
         limit: list[str] | None = None,
         user_id: str = SYSTEM_USER_ID,
+        at: Timestamp | None = None,
     ) -> None:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
-
+        at = Timestamp(at)
         branch = await registry.get_branch(branch=branch, db=db)
 
         for item_kind in schema.node_names + schema.generic_names_without_templates:
@@ -291,10 +295,10 @@ 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, user_id=user_id)
+                node = await self.load_node_to_db(node=item, branch=branch, db=db, at=at, 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, user_id=user_id)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
 
     async def load_node_to_db(
@@ -302,6 +306,7 @@ class SchemaManager(NodeManager):
         node: NodeSchema | GenericSchema,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Load a Node with its attributes and its relationships to the database."""
@@ -322,7 +327,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, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_node.id = obj.id
 
         # Then create the Attributes and the relationships
@@ -333,7 +338,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, user_id=user_id
+                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, at=at, user_id=user_id
                     )
                 else:
                     new_attr = item.duplicate()
@@ -342,7 +347,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, user_id=user_id
+                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, at=at, user_id=user_id
                     )
                 else:
                     new_rel = item.duplicate()
@@ -357,6 +362,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database."""
@@ -380,11 +386,11 @@ class SchemaManager(NodeManager):
         new_node = node.duplicate()
 
         # Update the attributes and the relationships nodes as well
-        await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id])
+        await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id], at=at)
         await obj.relationships.update(
-            db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"]
+            db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"], at=at
         )
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
 
         # Then Update the Attributes and the relationships
 
@@ -397,19 +403,19 @@ class SchemaManager(NodeManager):
 
         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, user_id=user_id)
+                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, at=at, 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, user_id=user_id
+                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, at=at, 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, user_id=user_id)
+                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, at=at, 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, user_id=user_id
+                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                 )
                 new_node.relationships.append(new_rel)
 
@@ -423,6 +429,7 @@ class SchemaManager(NodeManager):
         diff: HashableModelDiff,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database based on a HashableModelDiff."""
@@ -496,24 +503,24 @@ class SchemaManager(NodeManager):
             items.update({field.id: field for field in missing_attrs + missing_rels})
 
         if diff_attributes:
-            await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id])
+            await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id], at=at)
 
         if diff_relationships:
-            await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id])
+            await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id], at=at)
 
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, 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, user_id=user_id
+                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, at=at, 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, user_id=user_id)
+                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, at=at, 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, user_id=user_id)
                 elif (
@@ -530,12 +537,12 @@ 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, user_id=user_id
+                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, at=at, 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, user_id=user_id)
+                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, at=at, 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, user_id=user_id)
                 elif (
@@ -555,7 +562,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, user_id=user_id)
+                    await field_schema.delete(db=db, at=at, 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)
@@ -566,6 +573,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> None:
         """Delete the node with its attributes and relationships."""
@@ -581,11 +589,11 @@ 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, user_id=user_id)
+            await attr_schema_node.delete(db=db, at=at, user_id=user_id)
         for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
-            await rel_schema_node.delete(db=db, user_id=user_id)
+            await rel_schema_node.delete(db=db, at=at, user_id=user_id)
 
-        await obj.delete(db=db, user_id=user_id)
+        await obj.delete(db=db, at=at, user_id=user_id)
 
     @staticmethod
     async def create_attribute_in_db(
@@ -595,20 +603,23 @@ class SchemaManager(NodeManager):
         parent: Node,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
     ) -> 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, user_id=user_id)
+        await obj.save(db=db, at=at, 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, user_id: str) -> None:
+    async def update_attribute_in_db(
+        item: AttributeSchema, attr: Node, db: InfrahubDatabase, at: Timestamp, 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, user_id=user_id)
+        await attr.save(db=db, at=at, user_id=user_id)
 
     @staticmethod
     async def create_relationship_in_db(
@@ -618,22 +629,23 @@ class SchemaManager(NodeManager):
         parent: Node,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
     ) -> 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, user_id=user_id)
+        await obj.save(db=db, at=at, 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, user_id: str
+        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, at: Timestamp, 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, user_id=user_id)
+        await rel.save(db=db, at=at, user_id=user_id)
 
     async def load_schema(
         self,

infrahub/core/schema/schema_branch.py

@@ -54,7 +54,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
-from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters, TextAttributeParameters
 from infrahub.core.schema.attribute_schema import get_attribute_schema_class_for_kind
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
@@ -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] = {}
@@ -501,11 +501,76 @@ class SchemaBranch:
 
         return fields or None
 
+    def _text_attr_needs_reconciliation(self, attr: AttributeSchema) -> bool:
+        """Check if a Text attribute needs reconciliation between deprecated fields and parameters."""
+        if not isinstance(attr.parameters, TextAttributeParameters):
+            return False
+        return (
+            attr.regex != attr.parameters.regex
+            or attr.min_length != attr.parameters.min_length
+            or attr.max_length != attr.parameters.max_length
+        )
+
+    def _reconcile_text_attr(self, attr: AttributeSchema) -> None:
+        """Reconcile a single Text attribute's deprecated fields with parameters.
+
+        Parameters take precedence over deprecated top-level fields when both are set.
+        """
+        if not isinstance(attr.parameters, TextAttributeParameters):
+            return
+
+        # Sync regex: parameters takes precedence
+        if attr.parameters.regex is not None:
+            attr.regex = attr.parameters.regex
+        elif attr.regex is not None:
+            attr.parameters.regex = attr.regex
+
+        # Sync min_length: parameters takes precedence
+        if attr.parameters.min_length is not None:
+            attr.min_length = attr.parameters.min_length
+        elif attr.min_length is not None:
+            attr.parameters.min_length = attr.min_length
+
+        # Sync max_length: parameters takes precedence
+        if attr.parameters.max_length is not None:
+            attr.max_length = attr.parameters.max_length
+        elif attr.max_length is not None:
+            attr.parameters.max_length = attr.max_length
+
+    def _reconcile_text_attribute_parameters(self, schema: SchemaRoot | None = None) -> None:
+        """Reconcile regex, min_length, max_length between deprecated fields and parameters for Text attributes.
+
+        Args:
+            schema: If provided, reconcile incoming schema data before merging.
+                   If None, reconcile already-loaded schemas (e.g., from database).
+        """
+        if schema:
+            # Incoming schema: modify in place
+            for item in schema.nodes + schema.generics:
+                for attr in item.attributes:
+                    self._reconcile_text_attr(attr)
+            return
+
+        # Loaded schemas: need to duplicate before modifying
+        for name in self.all_names:
+            node = self.get(name=name, duplicate=False)
+
+            if not any(self._text_attr_needs_reconciliation(attr) for attr in node.attributes):
+                continue
+
+            node = node.duplicate()
+            for attr in node.attributes:
+                self._reconcile_text_attr(attr)
+            self.set(name=name, schema=node)
+
     def load_schema(self, schema: SchemaRoot) -> None:
         """Load a SchemaRoot object and store all NodeSchema or GenericSchema.
 
         In the current implementation, if a schema object present in the SchemaRoot already exist, it will be overwritten.
         """
+        # Reconcile deprecated text attribute parameters before merging
+        self._reconcile_text_attribute_parameters(schema)
+
         for item in schema.nodes + schema.generics:
             try:
                 if item.id:
@@ -545,6 +610,7 @@ class SchemaBranch:
         self.generate_identifiers()
         self.process_default_values()
         self.process_deprecations()
+        self._reconcile_text_attribute_parameters()
         self.process_cardinality_counts()
         self.process_inheritance()
         self.process_hierarchy()

infrahub/core/utils.py

@@ -215,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:
@@ -229,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 = {}
@@ -254,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

@@ -36,7 +36,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params["null_value"] = NULL_VALUE
 
         query = """
-        MATCH p = (n:%(node_kind)s)
+        MATCH (n:%(node_kinds)s)
         CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
@@ -51,7 +51,10 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value
-        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kinds": f"{self.node_schema.kind}|Profile{self.node_schema.kind}|Template{self.node_schema.kind}",
+        }
 
         self.add_to_query(query)
         self.return_labels = ["node.uuid", "attribute_value", "value_relationship.branch as value_branch"]
@@ -89,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
 

infrahub/core/validators/node/attribute.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 class NodeAttributeAddChecker(ConstraintCheckerInterface):
     query_classes = [NodeNotPresentValidatorQuery]
 
-    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/node/relationship.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class NodeRelationshipAddChecker(ConstraintCheckerInterface):
     query_classes = [NodeNotPresentValidatorQuery]
 
-    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/relationship/peer.py

@@ -136,7 +136,7 @@ class RelationshipPeerParentValidatorQuery(RelationshipSchemaValidatorQuery):
         parent_relationship: RelationshipSchema,
         peer_parent_relationship: RelationshipSchema,
         **kwargs: Any,
-    ):
+    ) -> None:
         super().__init__(**kwargs)
 
         self.relationship = relationship

infrahub/database/__init__.py

@@ -152,7 +152,7 @@ class InfrahubDatabase:
         session_mode: InfrahubDatabaseSessionMode = InfrahubDatabaseSessionMode.WRITE,
         transaction: AsyncTransaction | None = None,
         queries_names_to_config: dict[str, QueryConfig] | None = None,
-    ):
+    ) -> None:
         self._mode: InfrahubDatabaseMode = mode
         self._driver: AsyncDriver = driver
         self._session: AsyncSession | None = session

infrahub/git/utils.py

@@ -16,9 +16,9 @@ from infrahub_sdk.types import Order
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
+from infrahub.core.order import OrderModel
 from infrahub.database import InfrahubDatabase
 from infrahub.generators.models import ProposedChangeGeneratorDefinition
-from infrahub.graphql.models import OrderModel
 
 from .. import config
 from .models import RepositoryBranchInfo, RepositoryData

infrahub/graphql/app.py

@@ -172,9 +172,9 @@ class InfrahubGraphQLApp:
 
         response = handler(request)
         if isawaitable(response):
-            return await cast("Awaitable[Response]", response)
+            return await response
 
-        return cast("Response", response)
+        return response
 
     async def _handle_http_request(
         self, request: Request, db: InfrahubDatabase, branch: Branch, account_session: AccountSession

infrahub/graphql/field_extractor.py

@@ -12,7 +12,7 @@ from graphql import (
 class GraphQLFieldExtractor:
     """Class to extract fields from a GraphQL selection set."""
 
-    def __init__(self, info: GraphQLResolveInfo):
+    def __init__(self, info: GraphQLResolveInfo) -> None:
         self.info = info
         self.fragments = info.fragments