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

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)
 
@@ -892,6 +888,8 @@ class RelationshipManager:
         """If the attribute is branch aware, return the Branch object associated with this attribute
         If the attribute is branch agnostic return the Global Branch
 
+        Note that if this relationship is Aware and source node is Agnostic, it will return -global- branch.
+
         Returns:
             Branch:
         """
@@ -902,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:
@@ -944,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:
@@ -967,7 +965,7 @@ class RelationshipManager:
         self.has_fetched_relationships = True
 
         for peer_id in details.peer_ids_present_local_only:
-            await self.remove(peer_id=peer_id, db=db)
+            await self.remove_locally(peer_id=peer_id, db=db)
 
     async def get(self, db: InfrahubDatabase) -> Relationship | list[Relationship] | None:
         rels = await self.get_relationships(db=db)
@@ -1006,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
 
@@ -1069,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}"})
@@ -1098,22 +1094,17 @@ class RelationshipManager:
         for rel in self._relationships:
             await rel.resolve(db=db)
 
-    async def remove(
+    async def remove_locally(
         self,
-        peer_id: Union[str, UUID],
+        peer_id: str | UUID,
         db: InfrahubDatabase,
-        update_db: bool = False,
     ) -> bool:
-        """Remove a peer id from the local relationships list,
-        need to investigate if and when we should update the relationship in the database."""
+        """Remove a peer id from the local relationships list"""
 
         for idx, rel in enumerate(await self.get_relationships(db=db)):
             if str(rel.peer_id) != str(peer_id):
                 continue
 
-            if update_db:
-                await rel.delete(db=db)
-
             self._relationships.pop(idx)
             return True
 
@@ -1123,21 +1114,20 @@ 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()
 
         # - Update the existing relationship if we are on the same branch
         rel_ids_per_branch = peer_data.rel_ids_per_branch()
+
+        # In which cases do we end up here and do not want to set `to` time?
         if branch.name in rel_ids_per_branch:
             await update_relationships_to([str(ri) for ri in rel_ids_per_branch[branch.name]], to=remove_at, db=db)
 
         # - Create a new rel of type DELETED if the existing relationship is on a different branch
-        rel_branches: set[str] = set()
-        if peer_data.rels:
-            rel_branches = {r.branch for r in peer_data.rels}
-        if rel_branches == {peer_data.branch}:
+        if peer_data.rels and {r.branch for r in peer_data.rels} == {peer_data.branch}:
             return
 
         query = await RelationshipDataDeleteQuery.init(
@@ -1152,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."""
 
@@ -1198,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."""
 
@@ -1208,14 +1198,16 @@ class RelationshipManager:
         await self._fetch_relationships(at=delete_at, db=db, force_refresh=True)
 
         for rel in await self.get_relationships(db=db):
-            relationship_mapper.delete_relationship(relationship=rel)
+            relationship_mapper.delete_relationship(
+                peer_kind=rel.get_peer_kind(), peer_id=rel.get_peer_id(), rel_schema=rel.schema
+            )
             await rel.delete(at=delete_at, db=db)
 
         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

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import enum
-from typing import TYPE_CHECKING, Any, Optional, Union
+from enum import Enum
+from typing import TYPE_CHECKING, Any
 
 from pydantic import field_validator, model_validator
 
@@ -22,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:
@@ -36,6 +37,13 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    def to_dict(self) -> dict:
+        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
+        return data
+
     @field_validator("kind")
     @classmethod
     def kind_options(cls, v: str) -> str:
@@ -48,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")
@@ -74,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()
@@ -113,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]]: