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

infrahub/core/query/relationship.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import inspect
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generator, Optional, Union
+from typing import TYPE_CHECKING, Generator
 
 from infrahub_sdk.uuidt import UUIDT
 
@@ -79,24 +79,24 @@ class RelationshipPeerData:
     peer_kind: str
     """Kind of the Peer Node."""
 
-    properties: dict[str, Union[FlagPropertyData, NodePropertyData]]
+    properties: dict[str, FlagPropertyData | NodePropertyData]
     """UUID of the Relationship Node."""
 
-    rel_node_id: Optional[UUID] = None
+    rel_node_id: UUID | None = None
     """UUID of the Relationship Node."""
 
-    peer_db_id: Optional[str] = None
+    peer_db_id: str | None = None
     """Internal DB ID of the Peer Node."""
 
-    rel_node_db_id: Optional[str] = None
+    rel_node_db_id: str | None = None
     """Internal DB ID of the Relationship Node."""
 
-    rels: Optional[list[RelData]] = None
+    rels: list[RelData] | None = None
     """Both relationships pointing at this Relationship Node."""
 
-    updated_at: Optional[str] = None
+    updated_at: str | None = None
 
-    def rel_ids_per_branch(self) -> dict[str, list[Union[str, int]]]:
+    def rel_ids_per_branch(self) -> dict[str, list[str | int]]:
         response = defaultdict(list)
         for rel in self.rels:
             response[rel.branch].append(rel.db_id)
@@ -137,15 +137,15 @@ class FullRelationshipIdentifier:
 class RelationshipQuery(Query):
     def __init__(
         self,
-        rel: Union[type[Relationship], Relationship] | None = None,
-        rel_type: Optional[str] = None,
+        rel: type[Relationship] | Relationship | None = None,
+        rel_type: str | None = None,
         source: Node | None = None,
         source_id: UUID | None = None,
         destination: Node | None = None,
         destination_id: UUID | None = None,
         schema: RelationshipSchema | None = None,
         branch: Branch | None = None,
-        at: Union[Timestamp, str] | None = None,
+        at: Timestamp | str | None = None,
         **kwargs,
     ):
         if not source and not source_id:
@@ -185,7 +185,7 @@ class RelationshipQuery(Query):
 
         super().__init__(**kwargs)
 
-    def get_relationship_properties_dict(self, status: RelationshipStatus) -> dict[str, Optional[str]]:
+    def get_relationship_properties_dict(self, status: RelationshipStatus) -> dict[str, str | None]:
         rel_prop_dict = {
             "branch": self.branch.name,
             "branch_level": self.branch.hierarchy_level,
@@ -523,15 +523,15 @@ class RelationshipGetPeerQuery(Query):
 
     def __init__(
         self,
-        filters: Optional[dict] = None,
-        source: Optional[Node] = None,
-        source_ids: Optional[list[str]] = None,
-        source_kind: Optional[str] = None,
-        rel: Optional[Union[type[Relationship], Relationship]] = None,
-        rel_type: Optional[str] = None,
-        schema: Optional[RelationshipSchema] = None,
-        branch: Optional[Branch] = None,
-        at: Optional[Union[Timestamp, str]] = None,
+        filters: dict | None = None,
+        source: Node | None = None,
+        source_ids: list[str] | None = None,
+        source_kind: str | None = None,
+        rel: type[Relationship] | Relationship | None = None,
+        rel_type: str | None = None,
+        schema: RelationshipSchema | None = None,
+        branch: Branch | None = None,
+        at: Timestamp | str | None = None,
         **kwargs,
     ):
         if not source and not source_ids:
@@ -831,9 +831,9 @@ class RelationshipGetByIdentifierQuery(Query):
 
     def __init__(
         self,
-        identifiers: Optional[list[str]] = None,
-        full_identifiers: Optional[list[FullRelationshipIdentifier]] = None,
-        excluded_namespaces: Optional[list[str]] = None,
+        identifiers: list[str] | None = None,
+        full_identifiers: list[FullRelationshipIdentifier] | None = None,
+        excluded_namespaces: list[str] | None = None,
         **kwargs,
     ) -> None:
         if (not identifiers and not full_identifiers) or (identifiers and full_identifiers):

infrahub/core/query/resource_manager.py

@@ -276,6 +276,8 @@ class NumberPoolSetReserved(Query):
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })
         MERGE (value:AttributeValue { value: $reserved, is_default: false })
+        WITH value, pool
+        LIMIT 1
         CREATE (pool)-[rel:IS_RESERVED $rel_prop]->(value)
         """ % {"number_pool": InfrahubKind.NUMBERPOOL}
 

infrahub/core/query/standard_node.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.query import Query, QueryType
 
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
 class StandardNodeQuery(Query):
     def __init__(
-        self, node: StandardNode = None, node_id: Optional[str] = None, node_db_id: Optional[int] = None, **kwargs: Any
+        self, node: StandardNode = None, node_id: str | None = None, node_db_id: int | None = None, **kwargs: Any
     ):
         self.node = node
         self.node_id = node_id
@@ -120,7 +120,7 @@ class StandardNodeGetListQuery(Query):
     type = QueryType.READ
 
     def __init__(
-        self, node_class: StandardNode, ids: Optional[list[str]] = None, node_name: Optional[str] = None, **kwargs: Any
+        self, node_class: StandardNode, ids: list[str] | None = None, node_name: str | None = None, **kwargs: Any
     ) -> None:
         self.ids = ids
         self.node_name = node_name

infrahub/core/query/subquery.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.query import QueryNode
 
@@ -17,16 +17,16 @@ async def build_subquery_filter(
     filter_name: str,
     filter_value: Any,
     branch_filter: str,
-    field: Optional[Union[AttributeSchema, RelationshipSchema]] = None,
+    field: AttributeSchema | RelationshipSchema | None = None,
     node_alias: str = "n",
-    name: Optional[str] = None,
+    name: str | None = None,
     branch: Branch = None,
     subquery_idx: int = 1,
     partial_match: bool = False,
     optional_match: bool = False,
     result_prefix: str = "filter",
     support_profiles: bool = False,
-    extra_tail_properties: Optional[dict[str, str]] = None,
+    extra_tail_properties: dict[str, str] | None = None,
 ) -> tuple[str, dict[str, Any], str]:
     support_profiles = (
         support_profiles and field and field.is_attribute and filter_name in ("value", "values", "isnull")
@@ -102,16 +102,16 @@ async def build_subquery_filter(
 
 async def build_subquery_order(
     db: InfrahubDatabase,
-    field: Union[AttributeSchema, RelationshipSchema],
+    field: AttributeSchema | RelationshipSchema,
     order_by: str,
     branch_filter: str,
     node_alias: str = "n",
-    name: Optional[str] = None,
+    name: str | None = None,
     branch: Branch = None,
     subquery_idx: int = 1,
-    result_prefix: Optional[str] = None,
+    result_prefix: str | None = None,
     support_profiles: bool = False,
-    extra_tail_properties: Optional[dict[str, str]] = None,
+    extra_tail_properties: dict[str, str] | None = None,
 ) -> tuple[str, dict[str, Any], str]:
     support_profiles = support_profiles and field and field.is_attribute and order_by in ("value", "values")
     params = {}
@@ -143,7 +143,7 @@ async def build_subquery_order(
     branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
     froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")
     to_return_parts = {f"last.{order_by if order_by != 'values' and '__' not in order_by else 'value'}": prefix}
-    with_parts: dict[str, Optional[str]] = {
+    with_parts: dict[str, str | None] = {
         "last": None,
     }
     if extra_tail_properties:

infrahub/core/registry.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from infrahub import lock
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
@@ -26,21 +26,21 @@ if TYPE_CHECKING:
 
 @dataclass
 class Registry:
-    id: Optional[str] = None
+    id: str | None = None
     attribute: dict[str, type[BaseAttribute]] = field(default_factory=dict)
     branch: dict[str, Branch] = field(default_factory=dict)
     node: dict = field(default_factory=dict)
-    _default_branch: Optional[str] = None
-    _default_ipnamespace: Optional[str] = None
-    _schema: Optional[SchemaManager] = None
+    _default_branch: str | None = None
+    _default_ipnamespace: str | None = None
+    _schema: SchemaManager | None = None
     default_graphql_type: dict[str, InfrahubObject | type[BaseAttribute]] = field(default_factory=dict)
     graphql_type: dict = field(default_factory=lambda: defaultdict(dict))
     data_type: dict[str, type[InfrahubDataType]] = field(default_factory=dict)
     input_type: dict[str, type[BaseAttributeCreate | BaseAttributeUpdate]] = field(default_factory=dict)
     attr_group: dict = field(default_factory=dict)
-    _branch_object: Optional[type[Branch]] = None
-    _manager: Optional[type[NodeManager]] = None
-    _storage: Optional[InfrahubObjectStorage] = None
+    _branch_object: type[Branch] | None = None
+    _manager: type[NodeManager] | None = None
+    _storage: InfrahubObjectStorage | None = None
     permission_backends: list[PermissionBackend] = field(default_factory=list)
 
     @property
@@ -113,7 +113,7 @@ class Registry:
             return True
         return False
 
-    def get_node_schema(self, name: str, branch: Optional[Union[Branch, str]] = None) -> NodeSchema:
+    def get_node_schema(self, name: str, branch: Branch | str | None = None) -> NodeSchema:
         return self.schema.get_node_schema(name=name, branch=branch)
 
     def get_data_type(self, name: str) -> type[InfrahubDataType]:
@@ -121,9 +121,7 @@ class Registry:
             raise DataTypeNotFoundError(name=name)
         return self.data_type[name]
 
-    def get_full_schema(
-        self, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
-    ) -> dict[str, MainSchemaTypes]:
+    def get_full_schema(self, branch: Branch | str | None = None, duplicate: bool = True) -> dict[str, MainSchemaTypes]:
         """Return all the nodes in the schema for a given branch."""
         return self.schema.get_full(branch=branch, duplicate=duplicate)
 
@@ -137,7 +135,7 @@ class Registry:
         self.attribute = {}
         self.input_type = {}
 
-    def get_branch_from_registry(self, branch: Optional[Union[Branch, str]] = None) -> Branch:
+    def get_branch_from_registry(self, branch: Branch | str | None = None) -> Branch:
         """Return a branch object from the registry based on its name.
 
         Args:
@@ -168,8 +166,8 @@ class Registry:
     async def get_branch(
         self,
         db: InfrahubDatabase,
-        session: Optional[AsyncSession] = None,
-        branch: Optional[Union[Branch, str]] = None,
+        session: AsyncSession | None = None,
+        branch: Branch | str | None = None,
     ) -> Branch:
         """Return a branch object based on its name.
 

infrahub/core/relationship/constraints/count.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
@@ -17,12 +16,12 @@ from .interface import RelationshipManagerConstraintInterface
 class NodeToValidate:
     uuid: str
     cardinality: RelationshipCardinality
-    min_count: Optional[int] = None
-    max_count: Optional[int] = None
+    min_count: int | None = None
+    max_count: int | None = None
 
 
 class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/peer_kind.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
@@ -18,12 +17,12 @@ from .interface import RelationshipManagerConstraintInterface
 class NodeToValidate:
     uuid: str
     cardinality: RelationshipCardinality
-    min_count: Optional[int] = None
-    max_count: Optional[int] = None
+    min_count: int | None = None
+    max_count: int | None = None
 
 
 class RelationshipPeerKindConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/relationship/constraints/profiles_kind.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core import registry
 from infrahub.core.schema import NodeSchema
@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 
 
 class RelationshipProfilesKindConstraint(RelationshipManagerConstraintInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)

infrahub/core/relationship/model.py

@@ -11,10 +11,8 @@ from typing import (
     Iterator,
     Literal,
     Mapping,
-    Optional,
     Sequence,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -65,14 +63,14 @@ class RelationshipCreateData(BaseModel):
     uuid: str
     name: str
     destination_id: str
-    branch: Optional[str] = None
+    branch: str | None = None
     branch_level: int
-    branch_support: Optional[str] = None
+    branch_support: str | None = None
     direction: str
     status: str
     is_protected: bool
     is_visible: bool
-    hierarchical: Optional[str] = None
+    hierarchical: str | None = None
     source_prop: list[NodePropertyData] = Field(default_factory=list)
     owner_prop: list[NodePropertyData] = Field(default_factory=list)
 
@@ -92,9 +90,9 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         self,
         schema: RelationshipSchema,
         branch: Branch,
-        at: Optional[Timestamp] = None,
-        node: Optional[Node] = None,
-        node_id: Optional[str] = None,
+        at: Timestamp | None = None,
+        node: Node | None = None,
+        node_id: str | None = None,
         **kwargs: Any,
     ) -> None:
         if not node and not node_id:
@@ -107,18 +105,18 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         self.at = Timestamp(at)
 
         self._node = node
-        self._node_id: Optional[str] = node_id
+        self._node_id: str | None = node_id
 
-        self.id: Optional[UUID] = None
-        self.db_id: Optional[str] = None
-        self.updated_at: Optional[Timestamp] = None
+        self.id: UUID | None = None
+        self.db_id: str | None = None
+        self.updated_at: Timestamp | None = None
 
-        self._peer: Optional[Union[Node, str]] = None
-        self.peer_id: Optional[str] = None
-        self.peer_hfid: Optional[list[str]] = None
-        self.data: Optional[Union[dict, RelationshipPeerData, str]] = None
+        self._peer: Node | str | None = None
+        self.peer_id: str | None = None
+        self.peer_hfid: list[str] | None = None
+        self.data: dict | RelationshipPeerData | str | None = None
 
-        self.from_pool: Optional[dict[str, Any]] = None
+        self.from_pool: dict[str, Any] | None = None
 
         self._init_node_property_mixin(kwargs=kwargs)
         self._init_flag_property_mixin(kwargs=kwargs)
@@ -166,7 +164,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             return registry.get_global_branch()
         return self.branch
 
-    async def _process_data(self, data: Union[dict, RelationshipPeerData, str]) -> None:
+    async def _process_data(self, data: dict | RelationshipPeerData | str) -> None:
         self.data = data
 
         if isinstance(data, RelationshipPeerData):
@@ -203,7 +201,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
     async def new(
         self,
         db: InfrahubDatabase,  # noqa: ARG002
-        data: Union[dict, RelationshipPeerData, Any] = None,
+        data: dict | RelationshipPeerData | Any = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> Relationship:
         await self._process_data(data=data)
@@ -213,10 +211,10 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
     async def load(
         self,
         db: InfrahubDatabase,  # noqa: ARG002
-        id: Optional[UUID] = None,
-        db_id: Optional[str] = None,
-        updated_at: Optional[Union[Timestamp, str]] = None,
-        data: Union[dict, RelationshipPeerData, Any] = None,
+        id: UUID | None = None,
+        db_id: str | None = None,
+        updated_at: Timestamp | str | None = None,
+        data: dict | RelationshipPeerData | Any = None,
     ) -> Self:
         hash_before = hash(self)
 
@@ -252,7 +250,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         self._node_id = self._node.id
         return node
 
-    async def set_peer(self, value: Union[str, Node]) -> None:
+    async def set_peer(self, value: str | Node) -> None:
         if isinstance(value, str):
             self.peer_id = value
         else:
@@ -337,7 +335,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
 
         return different_properties
 
-    async def _create(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
+    async def _create(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
         """Add a relationship with another object by creating a new relationship node."""
 
         create_at = Timestamp(at)
@@ -364,7 +362,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         db: InfrahubDatabase,
         properties_to_update: list[str],
         data: RelationshipPeerData,
-        at: Optional[Timestamp] = None,
+        at: Timestamp | None = None,
     ) -> None:
         """Update the properties of an existing relationship."""
 
@@ -392,7 +390,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         )
         await query.execute(db=db)
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
+    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
         delete_at = Timestamp(at)
 
         node = await self.get_node(db=db)
@@ -476,7 +474,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             await self.set_peer(value=assigned_peer)
             self.set_source(value=pool.id)
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> Self:
+    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None) -> Self:
         """Create or Update the Relationship in the database."""
 
         save_at = Timestamp(at)
@@ -487,9 +485,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
 
         return self
 
-    async def to_graphql(
-        self, fields: Optional[dict], db: InfrahubDatabase, related_node_ids: Optional[set] = None
-    ) -> dict:
+    async def to_graphql(self, fields: dict | None, db: InfrahubDatabase, related_node_ids: set | None = None) -> dict:
         """Generate GraphQL Payload for the associated Peer."""
 
         if not fields:
@@ -726,7 +722,7 @@ class RelationshipManager:
             min_count=0 if self.schema.optional else self.schema.min_count,
             max_count=self.schema.max_count,
         )
-        self._relationship_id_details: Optional[RelationshipUpdateDetails] = None
+        self._relationship_id_details: RelationshipUpdateDetails | None = None
         self.has_fetched_relationships: bool = False
         self.lock = asyncio.Lock()
 
@@ -738,7 +734,7 @@ class RelationshipManager:
         branch: Branch,
         at: Timestamp,
         node: Node,
-        data: Optional[Union[dict, list, str]] = None,
+        data: dict | list | str | None = None,
     ) -> RelationshipManager:
         rm = cls(schema=schema, branch=branch, at=at, node=node)
 
@@ -904,7 +900,7 @@ class RelationshipManager:
     async def fetch_relationship_ids(
         self,
         db: InfrahubDatabase,
-        at: Optional[Timestamp] = None,
+        at: Timestamp | None = None,
         branch_agnostic: bool = False,
         force_refresh: bool = True,
     ) -> RelationshipUpdateDetails:
@@ -946,7 +942,7 @@ class RelationshipManager:
     async def _fetch_relationships(
         self,
         db: InfrahubDatabase,
-        at: Optional[Timestamp] = None,
+        at: Timestamp | None = None,
         branch_agnostic: bool = False,
         force_refresh: bool = True,
     ) -> None:
@@ -1008,12 +1004,10 @@ class RelationshipManager:
 
         return self._relationships.as_list()
 
-    async def update(
-        self, data: Union[list[Union[str, Node]], dict[str, Any], str, Node, None], db: InfrahubDatabase
-    ) -> bool:
+    async def update(self, data: list[str | Node] | dict[str, Any] | str | Node | None, db: InfrahubDatabase) -> bool:
         """Replace and Update the list of relationships with this one."""
         if not isinstance(data, list):
-            list_data: Sequence[Union[str, Node, dict[str, Any], None]] = [data]
+            list_data: Sequence[str | Node | dict[str, Any] | None] = [data]
         else:
             list_data = data
 
@@ -1071,7 +1065,7 @@ class RelationshipManager:
 
         return changed
 
-    async def add(self, data: Union[dict[str, Any], Node], db: InfrahubDatabase) -> bool:
+    async def add(self, data: dict[str, Any] | Node, db: InfrahubDatabase) -> bool:
         """Add a new relationship to the list of existing ones, avoid duplication."""
         if not isinstance(data, self.rel_class | dict) and not hasattr(data, "_schema"):
             raise ValidationError({self.name: f"Invalid data provided to form a relationship {data}"})
@@ -1102,7 +1096,7 @@ class RelationshipManager:
 
     async def remove_locally(
         self,
-        peer_id: Union[str, UUID],
+        peer_id: str | UUID,
         db: InfrahubDatabase,
     ) -> bool:
         """Remove a peer id from the local relationships list"""
@@ -1120,7 +1114,7 @@ class RelationshipManager:
         self,
         db: InfrahubDatabase,
         peer_data: RelationshipPeerData,
-        at: Optional[Timestamp] = None,
+        at: Timestamp | None = None,
     ) -> None:
         remove_at = Timestamp(at)
         branch = self.get_branch_based_on_support_type()
@@ -1148,7 +1142,7 @@ class RelationshipManager:
         await query.execute(db=db)
 
     async def save(
-        self, db: InfrahubDatabase, at: Optional[Timestamp] = None
+        self, db: InfrahubDatabase, at: Timestamp | None = None
     ) -> RelationshipCardinalityManyChangelog | RelationshipCardinalityOneChangelog:
         """Create or Update the Relationship in the database."""
 
@@ -1194,7 +1188,7 @@ class RelationshipManager:
         return relationship_mapper.changelog
 
     async def delete(
-        self, db: InfrahubDatabase, at: Optional[Timestamp] = None
+        self, db: InfrahubDatabase, at: Timestamp | None = None
     ) -> RelationshipCardinalityManyChangelog | RelationshipCardinalityOneChangelog:
         """Delete all the relationships."""
 
@@ -1212,8 +1206,8 @@ class RelationshipManager:
         return relationship_mapper.changelog
 
     async def to_graphql(
-        self, db: InfrahubDatabase, fields: Optional[dict] = None, related_node_ids: Optional[set] = None
-    ) -> Union[dict, None]:
+        self, db: InfrahubDatabase, fields: dict | None = None, related_node_ids: set | None = None
+    ) -> dict | None:
         # NOTE Need to investigate when and why we are passing the peer directly here, how do we account for many relationship
         if self.schema.cardinality == "many":
             raise TypeError("to_graphql is not available for relationship with multiple cardinality")

infrahub/core/schema/attribute_schema.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from pydantic import field_validator, model_validator
 
@@ -23,7 +23,7 @@ if TYPE_CHECKING:
 
 class AttributeSchema(GeneratedAttributeSchema):
     _sort_by: list[str] = ["name"]
-    _enum_class: Optional[type[enum.Enum]] = None
+    _enum_class: type[enum.Enum] | None = None
 
     @property
     def is_attribute(self) -> bool:
@@ -38,7 +38,7 @@ class AttributeSchema(GeneratedAttributeSchema):
         return bool(self.deprecation)
 
     def to_dict(self) -> dict:
-        data = self.model_dump(exclude_unset=True, exclude_none=True, exclude_defaults=True)
+        data = self.model_dump(exclude_unset=True, exclude_none=True)
         for field_name, value in data.items():
             if isinstance(value, Enum):
                 data[field_name] = value.value
@@ -56,7 +56,7 @@ class AttributeSchema(GeneratedAttributeSchema):
     def validate_dropdown_choices(cls, values: dict[str, Any]) -> dict[str, Any]:
         """Validate that choices are defined for a dropdown but not for other kinds."""
         if values.get("kind") != "Dropdown" and values.get("choices"):
-            raise ValueError(f"Can only specify 'choices' for kind=Dropdown: {values['kind'] }")
+            raise ValueError(f"Can only specify 'choices' for kind=Dropdown: {values['kind']}")
 
         if values.get("kind") == "Dropdown" and not values.get("choices"):
             raise ValueError("The property 'choices' is required for kind=Dropdown")
@@ -82,7 +82,7 @@ class AttributeSchema(GeneratedAttributeSchema):
             self._enum_class = generate_python_enum(name=f"{self.name.title()}Enum", options=self.enum)
         return self._enum_class
 
-    def convert_value_to_enum(self, value: Any) -> Optional[enum.Enum]:
+    def convert_value_to_enum(self, value: Any) -> enum.Enum | None:
         if isinstance(value, enum.Enum) or value is None:
             return value
         enum_class = self.get_enum_class()
@@ -121,11 +121,11 @@ class AttributeSchema(GeneratedAttributeSchema):
         self,
         name: str,
         filter_name: str,
-        branch: Optional[Branch] = None,
-        filter_value: Optional[Union[str, int, bool, list]] = None,
+        branch: Branch | None = None,
+        filter_value: str | int | bool | list | None = None,
         include_match: bool = True,
-        param_prefix: Optional[str] = None,
-        db: Optional[InfrahubDatabase] = None,
+        param_prefix: str | None = None,
+        db: InfrahubDatabase | None = None,
         partial_match: bool = False,
         support_profiles: bool = False,
     ) -> tuple[list[QueryElement], dict[str, Any], list[str]]: