infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/node/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Sequence, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Sequence, TypeVar, overload
 
 from infrahub_sdk.utils import is_valid_uuid
 from infrahub_sdk.uuidt import UUIDT
@@ -63,7 +63,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         _meta.default_filter = default_filter
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
-    def get_schema(self) -> Union[NodeSchema, ProfileSchema, TemplateSchema]:
+    def get_schema(self) -> NodeSchema | ProfileSchema | TemplateSchema:
         return self._schema
 
     def get_kind(self) -> str:
@@ -80,17 +80,18 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     def get_updated_at(self) -> Timestamp | None:
         return self._updated_at
 
-    async def get_hfid(self, db: InfrahubDatabase, include_kind: bool = False) -> Optional[list[str]]:
+    async def get_hfid(self, db: InfrahubDatabase, include_kind: bool = False) -> list[str] | None:
         """Return the Human friendly id of the node."""
         if not self._schema.human_friendly_id:
             return None
 
-        hfid = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+        hfid_values = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+        hfid = [value for value in hfid_values if value is not None]
         if include_kind:
             return [self.get_kind()] + hfid
         return hfid
 
-    async def get_hfid_as_string(self, db: InfrahubDatabase, include_kind: bool = False) -> Optional[str]:
+    async def get_hfid_as_string(self, db: InfrahubDatabase, include_kind: bool = False) -> str | None:
         """Return the Human friendly id of the node in string format separated with a dunder (__) ."""
         hfid = await self.get_hfid(db=db, include_kind=include_kind)
         if not hfid:
@@ -160,18 +161,18 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return f"{self.get_kind()}(ID: {str(self.id)})"
 
-    def __init__(self, schema: Union[NodeSchema, ProfileSchema, TemplateSchema], branch: Branch, at: Timestamp):
-        self._schema: Union[NodeSchema, ProfileSchema, TemplateSchema] = schema
+    def __init__(self, schema: NodeSchema | ProfileSchema | TemplateSchema, branch: Branch, at: Timestamp):
+        self._schema: NodeSchema | ProfileSchema | TemplateSchema = schema
         self._branch: Branch = branch
         self._at: Timestamp = at
         self._existing: bool = False
 
-        self._updated_at: Optional[Timestamp] = None
+        self._updated_at: Timestamp | None = None
         self.id: str = None
         self.db_id: str = None
 
-        self._source: Optional[Node] = None
-        self._owner: Optional[Node] = None
+        self._source: Node | None = None
+        self._owner: Node | None = None
         self._is_protected: bool = None
         self._computed_jinja2_attributes: list[str] = []
 
@@ -191,10 +192,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, TemplateSchema, str],
+        schema: NodeSchema | ProfileSchema | TemplateSchema | str,
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = ...,
-        at: Optional[Union[Timestamp, str]] = ...,
+        branch: Branch | str | None = ...,
+        at: Timestamp | str | None = ...,
     ) -> Self: ...
 
     @overload
@@ -203,17 +204,17 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         cls,
         schema: type[SchemaProtocol],
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = ...,
-        at: Optional[Union[Timestamp, str]] = ...,
+        branch: Branch | str | None = ...,
+        at: Timestamp | str | None = ...,
     ) -> SchemaProtocol: ...
 
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, TemplateSchema, str, type[SchemaProtocol]],
+        schema: NodeSchema | ProfileSchema | TemplateSchema | str | type[SchemaProtocol],
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = None,
-        at: Optional[Union[Timestamp, str]] = None,
+        branch: Branch | str | None = None,
+        at: Timestamp | str | None = None,
     ) -> Self | SchemaProtocol:
         attrs: dict[str, Any] = {}
 
@@ -546,7 +547,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         )
         return attr
 
-    async def process_label(self, db: Optional[InfrahubDatabase] = None) -> None:  # noqa: ARG002
+    async def process_label(self, db: InfrahubDatabase | None = None) -> None:  # noqa: ARG002
         # If there label and name are both defined for this node
         #  if label is not define, we'll automatically populate it with a human friendy vesion of name
         if not self._existing and hasattr(self, "label") and hasattr(self, "name"):
@@ -554,7 +555,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 self.label.value = " ".join([word.title() for word in self.name.value.split("_")])
                 self.label.is_default = False
 
-    async def new(self, db: InfrahubDatabase, id: Optional[str] = None, **kwargs: Any) -> Self:
+    async def new(self, db: InfrahubDatabase, id: str | None = None, **kwargs: Any) -> Self:
         if id and not is_valid_uuid(id):
             raise ValidationError({"id": f"{id} is not a valid UUID"})
         if id:
@@ -577,9 +578,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     async def load(
         self,
         db: InfrahubDatabase,
-        id: Optional[str] = None,
-        db_id: Optional[str] = None,
-        updated_at: Optional[Union[Timestamp, str]] = None,
+        id: str | None = None,
+        db_id: str | None = None,
+        updated_at: Timestamp | str | None = None,
         **kwargs: Any,
     ) -> Self:
         self.id = id
@@ -630,7 +631,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return node_changelog
 
     async def _update(
-        self, db: InfrahubDatabase, at: Optional[Timestamp] = None, fields: list[str] | None = None
+        self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None
     ) -> NodeChangelog:
         """Update the node in the database if needed."""
 
@@ -665,7 +666,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         node_changelog.display_label = await self.render_display_label(db=db)
         return node_changelog
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None, fields: list[str] | None = None) -> Self:
+    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None) -> Self:
         """Create or Update the Node in the database."""
 
         save_at = Timestamp(at)
@@ -677,7 +678,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         self._node_changelog = await self._create(at=save_at, db=db)
         return self
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
+    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
         """Delete the Node in the database."""
 
         delete_at = Timestamp(at)
@@ -770,7 +771,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     response[field_name] = None
                 continue
 
-            field: Optional[BaseAttribute] = getattr(self, field_name, None)
+            field: BaseAttribute | None = getattr(self, field_name, None)
 
             if not field:
                 response[field_name] = None
@@ -832,7 +833,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return changed
 
-    async def render_display_label(self, db: Optional[InfrahubDatabase] = None) -> str:  # noqa: ARG002
+    async def render_display_label(self, db: InfrahubDatabase | None = None) -> str:  # noqa: ARG002
         if not self._schema.display_labels:
             return repr(self)
 

infrahub/core/node/base.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from ..utils import SubclassWithMeta, SubclassWithMeta_Meta
 
 
 class BaseOptions:
-    name: Optional[str] = None
-    description: Optional[str] = None
+    name: str | None = None
+    description: str | None = None
 
     _frozen: bool = False
 

infrahub/core/node/constraints/attribute_uniqueness.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
@@ -18,7 +18,7 @@ class NodeAttributeUniquenessConstraint(NodeConstraintInterface):
         self.db = db
         self.branch = branch
 
-    async def check(self, node: Node, at: Optional[Timestamp] = None, filters: Optional[list[str]] = None) -> None:
+    async def check(self, node: Node, at: Timestamp | None = None, filters: list[str] | None = None) -> None:
         at = Timestamp(at)
         node_schema = node.get_schema()
         for unique_attr in node_schema.unique_attributes:

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Iterable
 
 from infrahub.core import registry
 from infrahub.core.constants import NULL_VALUE
@@ -9,6 +9,11 @@ from infrahub.core.schema import (
     SchemaAttributePath,
     SchemaAttributePathValue,
 )
+from infrahub.core.schema.basenode_schema import (
+    SchemaUniquenessConstraintPath,
+    UniquenessConstraintType,
+    UniquenessConstraintViolation,
+)
 from infrahub.core.validators.uniqueness.index import UniquenessQueryResultsIndex
 from infrahub.core.validators.uniqueness.model import (
     NodeUniquenessQueryRequest,
@@ -16,7 +21,7 @@ from infrahub.core.validators.uniqueness.model import (
     QueryRelationshipAttributePath,
 )
 from infrahub.core.validators.uniqueness.query import NodeUniqueAttributeConstraintQuery
-from infrahub.exceptions import ValidationError
+from infrahub.exceptions import HFIDViolatedError, ValidationError
 
 from .interface import NodeConstraintInterface
 
@@ -39,15 +44,15 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
         self,
         updated_node: Node,
         node_schema: MainSchemaTypes,
-        path_groups: list[list[SchemaAttributePath]],
-        filters: Optional[list[str]] = None,
+        uniqueness_constraint_paths: list[SchemaUniquenessConstraintPath],
+        filters: list[str] | None = None,
     ) -> NodeUniquenessQueryRequest:
         query_request = NodeUniquenessQueryRequest(kind=node_schema.kind)
-        for path_group in path_groups:
+        for uniqueness_constraint_path in uniqueness_constraint_paths:
             include_in_query = not filters
             query_relationship_paths: set[QueryRelationshipAttributePath] = set()
             query_attribute_paths: set[QueryAttributePath] = set()
-            for attribute_path in path_group:
+            for attribute_path in uniqueness_constraint_path.attributes_paths:
                 if attribute_path.related_schema and attribute_path.relationship_schema:
                     if filters and attribute_path.relationship_schema.name in filters:
                         include_in_query = True
@@ -118,71 +123,118 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
                 )
         return node_value_combination
 
-    def _check_one_constraint_group(
-        self, schema_attribute_path_values: list[SchemaAttributePathValue], results_index: UniquenessQueryResultsIndex
-    ) -> None:
-        # constraint cannot be violated if this node is missing any values
-        if any(sapv.value is None for sapv in schema_attribute_path_values):
-            return
-
-        matching_node_ids = results_index.get_node_ids_for_value_group(schema_attribute_path_values)
-        if not matching_node_ids:
-            return
-        uniqueness_constraint_fields = []
-        for sapv in schema_attribute_path_values:
-            if sapv.relationship_schema:
-                uniqueness_constraint_fields.append(sapv.relationship_schema.name)
-            elif sapv.attribute_schema:
-                uniqueness_constraint_fields.append(sapv.attribute_schema.name)
-        uniqueness_constraint_string = "-".join(uniqueness_constraint_fields)
-        error_msg = f"Violates uniqueness constraint '{uniqueness_constraint_string}'"
-        errors = [ValidationError({field_name: error_msg}) for field_name in uniqueness_constraint_fields]
-        raise ValidationError(errors)
-
-    async def _check_results(
+    async def _get_violations(
         self,
         updated_node: Node,
-        path_groups: list[list[SchemaAttributePath]],
+        uniqueness_constraint_paths: list[SchemaUniquenessConstraintPath],
         query_results: Iterable[QueryResult],
-    ) -> None:
+    ) -> list[UniquenessConstraintViolation]:
         results_index = UniquenessQueryResultsIndex(
             query_results=query_results, exclude_node_ids={updated_node.get_id()}
         )
-        for path_group in path_groups:
+        violations = []
+        for uniqueness_constraint_path in uniqueness_constraint_paths:
+            # path_group = one constraint (that can contain multiple items)
             schema_attribute_path_values = await self._get_node_attribute_path_values(
-                updated_node=updated_node, path_group=path_group
+                updated_node=updated_node, path_group=uniqueness_constraint_path.attributes_paths
             )
-            self._check_one_constraint_group(
-                schema_attribute_path_values=schema_attribute_path_values, results_index=results_index
+
+            # constraint cannot be violated if this node is missing any values
+            if any(sapv.value is None for sapv in schema_attribute_path_values):
+                continue
+
+            matching_node_ids = results_index.get_node_ids_for_value_group(schema_attribute_path_values)
+            if not matching_node_ids:
+                continue
+
+            uniqueness_constraint_fields = []
+            for sapv in schema_attribute_path_values:
+                if sapv.relationship_schema:
+                    uniqueness_constraint_fields.append(sapv.relationship_schema.name)
+                elif sapv.attribute_schema:
+                    uniqueness_constraint_fields.append(sapv.attribute_schema.name)
+
+            violations.append(
+                UniquenessConstraintViolation(
+                    nodes_ids=matching_node_ids,
+                    fields=uniqueness_constraint_fields,
+                    typ=uniqueness_constraint_path.typ,
+                )
             )
 
-    async def _check_one_schema(
+        return violations
+
+    async def _get_single_schema_violations(
         self,
         node: Node,
         node_schema: MainSchemaTypes,
-        at: Optional[Timestamp] = None,
-        filters: Optional[list[str]] = None,
-    ) -> None:
+        at: Timestamp | None = None,
+        filters: list[str] | None = None,
+    ) -> list[UniquenessConstraintViolation]:
         schema_branch = self.db.schema.get_schema_branch(name=self.branch.name)
-        path_groups = node_schema.get_unique_constraint_schema_attribute_paths(schema_branch=schema_branch)
+
+        uniqueness_constraint_paths = node_schema.get_unique_constraint_schema_attribute_paths(
+            schema_branch=schema_branch
+        )
         query_request = await self._build_query_request(
-            updated_node=node, node_schema=node_schema, path_groups=path_groups, filters=filters
+            updated_node=node,
+            node_schema=node_schema,
+            uniqueness_constraint_paths=uniqueness_constraint_paths,
+            filters=filters,
         )
         if not query_request:
-            return
+            return []
+
         query = await NodeUniqueAttributeConstraintQuery.init(
             db=self.db, branch=self.branch, at=at, query_request=query_request, min_count_required=0
         )
         await query.execute(db=self.db)
-        await self._check_results(updated_node=node, path_groups=path_groups, query_results=query.get_results())
+        return await self._get_violations(
+            updated_node=node,
+            uniqueness_constraint_paths=uniqueness_constraint_paths,
+            query_results=query.get_results(),
+        )
+
+    async def check(self, node: Node, at: Timestamp | None = None, filters: list[str] | None = None) -> None:
+        def _frozen_constraints(schema: MainSchemaTypes) -> frozenset[frozenset[str]]:
+            if not schema.uniqueness_constraints:
+                return frozenset()
+            return frozenset(frozenset(uc) for uc in schema.uniqueness_constraints)
 
-    async def check(self, node: Node, at: Optional[Timestamp] = None, filters: Optional[list[str]] = None) -> None:
         node_schema = node.get_schema()
-        schemas_to_check: list[MainSchemaTypes] = [node_schema]
+        include_node_schema = True
+        frozen_node_constraints = _frozen_constraints(node_schema)
+        schemas_to_check: list[MainSchemaTypes] = []
         if node_schema.inherit_from:
             for parent_schema_name in node_schema.inherit_from:
                 parent_schema = self.schema_branch.get(name=parent_schema_name, duplicate=False)
-                if parent_schema.uniqueness_constraints:
-                    schemas_to_check.append(parent_schema)
+                if not parent_schema.uniqueness_constraints:
+                    continue
+                schemas_to_check.append(parent_schema)
+                frozen_parent_constraints = _frozen_constraints(parent_schema)
+                if frozen_node_constraints <= frozen_parent_constraints:
+                    include_node_schema = False
+
+        if include_node_schema:
+            schemas_to_check.append(node_schema)
+
+        violations = []
         for schema in schemas_to_check:
-            await self._check_one_schema(node=node, node_schema=schema, at=at, filters=filters)
+            schema_violations = await self._get_single_schema_violations(
+                node=node, node_schema=schema, at=at, filters=filters
+            )
+            violations.extend(schema_violations)
+
+        is_hfid_violated = any(violation.typ == UniquenessConstraintType.HFID for violation in violations)
+
+        for violation in violations:
+            if violation.typ == UniquenessConstraintType.STANDARD or (
+                violation.typ == UniquenessConstraintType.SUBSET_OF_HFID and not is_hfid_violated
+            ):
+                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
+                raise ValidationError(error_msg)
+
+        for violation in violations:
+            if violation.typ == UniquenessConstraintType.HFID:
+                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
+                raise HFIDViolatedError(error_msg, matching_nodes_ids=violation.nodes_ids)

infrahub/core/node/constraints/interface.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from typing import Optional
 
 from infrahub.core.node import Node
 from infrahub.core.timestamp import Timestamp
@@ -7,4 +6,4 @@ from infrahub.core.timestamp import Timestamp
 
 class NodeConstraintInterface(ABC):
     @abstractmethod
-    async def check(self, node: Node, at: Optional[Timestamp] = None, filters: Optional[list[str]] = None) -> None: ...
+    async def check(self, node: Node, at: Timestamp | None = None, filters: list[str] | None = None) -> None: ...

infrahub/core/node/delete_validator.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from enum import Enum
-from typing import Iterable, Optional, Union
+from typing import Iterable
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
@@ -124,16 +124,14 @@ class NodeDeleteValidator:
         self._all_schemas_map = schema_branch.get_all(duplicate=False)
         self.index: NodeDeleteIndex = NodeDeleteIndex(all_schemas_map=self._all_schemas_map)
 
-    async def get_ids_to_delete(self, nodes: Iterable[Node], at: Optional[Union[Timestamp, str]] = None) -> set[str]:
+    async def get_ids_to_delete(self, nodes: Iterable[Node], at: Timestamp | str | None = None) -> set[str]:
         start_schemas = {node.get_schema() for node in nodes}
         self.index.index(start_schemas=start_schemas)
         at = Timestamp(at)
 
         return await self._analyze_delete_dependencies(start_nodes=nodes, at=at)
 
-    async def _analyze_delete_dependencies(
-        self, start_nodes: Iterable[Node], at: Optional[Union[Timestamp, str]]
-    ) -> set[str]:
+    async def _analyze_delete_dependencies(self, start_nodes: Iterable[Node], at: Timestamp | str | None) -> set[str]:
         full_relationship_identifiers = self.index.get_relationship_identifiers()
         if not full_relationship_identifiers:
             return {node.get_id() for node in start_nodes}

infrahub/core/node/ipam.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core.ipam.size import get_prefix_space
 from infrahub.core.ipam.utilization import PrefixUtilizationGetter
@@ -16,10 +16,10 @@ class BuiltinIPPrefix(Node):
     async def to_graphql(
         self,
         db: InfrahubDatabase,
-        fields: Optional[dict] = None,
-        related_node_ids: Optional[set] = None,
+        fields: dict | None = None,
+        related_node_ids: set | None = None,
         filter_sensitive: bool = False,
-        permissions: Optional[dict] = None,  # noqa: ARG002
+        permissions: dict | None = None,  # noqa: ARG002
         include_properties: bool = True,
     ) -> dict:
         response = await super().to_graphql(

infrahub/core/node/permissions.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.permissions.constants import PermissionDecisionFlag
 
@@ -14,10 +14,10 @@ class CoreGlobalPermission(Node):
     async def to_graphql(
         self,
         db: InfrahubDatabase,
-        fields: Optional[dict] = None,
-        related_node_ids: Optional[set] = None,
+        fields: dict | None = None,
+        related_node_ids: set | None = None,
         filter_sensitive: bool = False,
-        permissions: Optional[dict] = None,
+        permissions: dict | None = None,
         include_properties: bool = True,
     ) -> dict:
         response = await super().to_graphql(
@@ -41,10 +41,10 @@ class CoreObjectPermission(Node):
     async def to_graphql(
         self,
         db: InfrahubDatabase,
-        fields: Optional[dict] = None,
-        related_node_ids: Optional[set] = None,
+        fields: dict | None = None,
+        related_node_ids: set | None = None,
         filter_sensitive: bool = False,
-        permissions: Optional[dict] = None,
+        permissions: dict | None = None,
         include_properties: bool = True,
     ) -> dict:
         response = await super().to_graphql(

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ipaddress
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core import registry
 from infrahub.core.ipam.reconciler import IpamReconciler
@@ -26,10 +26,10 @@ class CoreIPAddressPool(Node):
         self,
         db: InfrahubDatabase,
         branch: Branch,
-        identifier: Optional[str] = None,
-        data: Optional[dict[str, Any]] = None,
-        address_type: Optional[str] = None,
-        prefixlen: Optional[int] = None,
+        identifier: str | None = None,
+        data: dict[str, Any] | None = None,
+        address_type: str | None = None,
+        prefixlen: int | None = None,
     ) -> Node:
         # Check if there is already a resource allocated with this identifier
         # if not, pull all existing prefixes and allocated the next available
@@ -80,7 +80,7 @@ class CoreIPAddressPool(Node):
 
         return node
 
-    async def get_next(self, db: InfrahubDatabase, prefixlen: Optional[int] = None) -> IPAddressType:
+    async def get_next(self, db: InfrahubDatabase, prefixlen: int | None = None) -> IPAddressType:
         # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ipaddress
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from netaddr import IPSet
 
@@ -28,11 +28,11 @@ class CoreIPPrefixPool(Node):
         self,
         db: InfrahubDatabase,
         branch: Branch,
-        identifier: Optional[str] = None,
-        data: Optional[dict[str, Any]] = None,
-        prefixlen: Optional[int] = None,
-        member_type: Optional[str] = None,
-        prefix_type: Optional[str] = None,
+        identifier: str | None = None,
+        data: dict[str, Any] | None = None,
+        prefixlen: int | None = None,
+        member_type: str | None = None,
+        prefix_type: str | None = None,
     ) -> Node:
         # Check if there is already a resource allocated with this identifier
         # if not, pull all existing prefixes and allocated the next available

infrahub/core/node/resource_manager/number_pool.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core.query.resource_manager import NumberPoolGetReserved, NumberPoolGetUsed, NumberPoolSetReserved
 from infrahub.exceptions import PoolExhaustedError
@@ -18,7 +18,7 @@ class CoreNumberPool(Node):
         db: InfrahubDatabase,
         branch: Branch,
         node: Node,
-        identifier: Optional[str] = None,
+        identifier: str | None = None,
     ) -> int:
         identifier = identifier or node.get_id()
         # Check if there is already a resource allocated with this identifier
@@ -55,7 +55,7 @@ class CoreNumberPool(Node):
         return next_number
 
 
-def find_next_free(start: int, end: int, taken: list[int | None]) -> Optional[int]:
+def find_next_free(start: int, end: int, taken: list[int | None]) -> int | None:
     used_numbers = [number for number in taken if number is not None]
     used_set = set(used_numbers)
 

infrahub/core/path.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, Field
 from typing_extensions import Self
@@ -56,12 +56,12 @@ class DataPath(InfrahubPath):
     path_type: PathType
     node_id: str = Field(..., description="Kind of the model in the schema")
     kind: str = Field(..., description="Kind of the main node")
-    field_name: Optional[str] = Field(
+    field_name: str | None = Field(
         default=None, description="Name of the field (either an attribute or a relationship)"
     )
-    property_name: Optional[str] = Field(default=None, description="Name of the property")
-    peer_id: Optional[str] = Field(default=None, description="")
-    value: Optional[Any] = Field(default=None, description="Optional value of the resource")
+    property_name: str | None = Field(default=None, description="Name of the property")
+    peer_id: str | None = Field(default=None, description="")
+    value: Any | None = Field(default=None, description="Optional value of the resource")
 
     @property
     def resource_type(self) -> PathResourceType:
@@ -109,11 +109,11 @@ class GroupedDataPaths:
 class SchemaPath(InfrahubPath):
     path_type: SchemaPathType
     schema_kind: str = Field(..., description="Kind of the model in the schema")
-    schema_id: Optional[str] = Field(default=None, description="UUID of the model in the schema")
-    field_name: Optional[str] = Field(
+    schema_id: str | None = Field(default=None, description="UUID of the model in the schema")
+    field_name: str | None = Field(
         default=None, description="Name of the field (either an attribute or a relationship)"
     )
-    property_name: Optional[str] = Field(default=None, description="Name of the property")
+    property_name: str | None = Field(default=None, description="Name of the property")
 
     @property
     def resource_type(self) -> PathResourceType:
@@ -133,10 +133,10 @@ class SchemaPath(InfrahubPath):
     @classmethod
     def init(
         cls,
-        schema: Union[NodeSchema, GenericSchema],
-        schema_id: Optional[str] = None,
-        field_name: Optional[str] = None,
-        property_name: Optional[str] = None,
+        schema: NodeSchema | GenericSchema,
+        schema_id: str | None = None,
+        field_name: str | None = None,
+        property_name: str | None = None,
     ) -> Self:
         if field_name and not schema.get_field(name=field_name, raise_on_error=False):
             raise ValueError(f"Field : {field_name} is not valid for {schema.kind}")