infrahub-server 1.3.0a0__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

infrahub_sdk/node/parsers.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from .constants import HFID_STR_SEPARATOR
+
+
+def parse_human_friendly_id(hfid: str | list[str]) -> tuple[str | None, list[str]]:
+    """Parse a human friendly ID into a kind and an identifier."""
+    if isinstance(hfid, str):
+        hfid_parts = hfid.split(HFID_STR_SEPARATOR)
+        if len(hfid_parts) == 1:
+            return None, hfid_parts
+        return hfid_parts[0], hfid_parts[1:]
+    if isinstance(hfid, list):
+        return None, hfid
+    raise ValueError(f"Invalid human friendly ID: {hfid}")

infrahub_sdk/node/property.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+
+class NodeProperty:
+    """Represents a property of a node, typically used for metadata like display labels."""
+
+    def __init__(self, data: dict | str):
+        """
+        Args:
+            data (Union[dict, str]): Data representing the node property.
+        """
+        self.id = None
+        self.display_label = None
+        self.typename = None
+
+        if isinstance(data, str):
+            self.id = data
+        elif isinstance(data, dict):
+            self.id = data.get("id", None)
+            self.display_label = data.get("display_label", None)
+            self.typename = data.get("__typename", None)
+
+    def _generate_input_data(self) -> str | None:
+        return self.id

infrahub_sdk/node/related_node.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from ..exceptions import (
+    Error,
+)
+from ..protocols_base import CoreNodeBase
+from .constants import PROPERTIES_FLAG, PROPERTIES_OBJECT
+
+if TYPE_CHECKING:
+    from ..client import InfrahubClient, InfrahubClientSync
+    from ..schema import RelationshipSchemaAPI
+    from .node import InfrahubNode, InfrahubNodeSync
+
+
+class RelatedNodeBase:
+    """Base class for representing a related node in a relationship."""
+
+    def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict, name: str | None = None):
+        """
+        Args:
+            branch (str): The branch where the related node resides.
+            schema (RelationshipSchema): The schema of the relationship.
+            data (Union[Any, dict]): Data representing the related node.
+            name (Optional[str]): The name of the related node.
+        """
+        self.schema = schema
+        self.name = name
+
+        self._branch = branch
+
+        self._properties_flag = PROPERTIES_FLAG
+        self._properties_object = PROPERTIES_OBJECT
+        self._properties = self._properties_flag + self._properties_object
+
+        self._peer = None
+        self._id: str | None = None
+        self._hfid: list[str] | None = None
+        self._display_label: str | None = None
+        self._typename: str | None = None
+
+        if isinstance(data, (CoreNodeBase)):
+            self._peer = data
+            for prop in self._properties:
+                setattr(self, prop, None)
+
+        elif isinstance(data, list):
+            data = {"hfid": data}
+        elif not isinstance(data, dict):
+            data = {"id": data}
+
+        if isinstance(data, dict):
+            # To support both with and without pagination, we split data into node_data and properties_data
+            # We should probably clean that once we'll remove the code without pagination.
+            node_data = data.get("node", data)
+            properties_data = data.get("properties", data)
+
+            if node_data:
+                self._id = node_data.get("id", None)
+                self._hfid = node_data.get("hfid", None)
+                self._kind = node_data.get("kind", None)
+                self._display_label = node_data.get("display_label", None)
+                self._typename = node_data.get("__typename", None)
+
+            self.updated_at: str | None = data.get("updated_at", data.get("_relation__updated_at", None))
+
+            # FIXME, we won't need that once we are only supporting paginated results
+            if self._typename and self._typename.startswith("Related"):
+                self._typename = self._typename[7:]
+
+            for prop in self._properties:
+                prop_data = properties_data.get(prop, properties_data.get(f"_relation__{prop}", None))
+                if prop_data and isinstance(prop_data, dict) and "id" in prop_data:
+                    setattr(self, prop, prop_data["id"])
+                elif prop_data and isinstance(prop_data, (str, bool)):
+                    setattr(self, prop, prop_data)
+                else:
+                    setattr(self, prop, None)
+
+    @property
+    def id(self) -> str | None:
+        if self._peer:
+            return self._peer.id
+        return self._id
+
+    @property
+    def hfid(self) -> list[Any] | None:
+        if self._peer:
+            return self._peer.hfid
+        return self._hfid
+
+    @property
+    def hfid_str(self) -> str | None:
+        if self._peer and self.hfid:
+            return self._peer.get_human_friendly_id_as_string(include_kind=True)
+        return None
+
+    @property
+    def is_resource_pool(self) -> bool:
+        if self._peer:
+            return self._peer.is_resource_pool()
+        return False
+
+    @property
+    def initialized(self) -> bool:
+        return bool(self.id) or bool(self.hfid)
+
+    @property
+    def display_label(self) -> str | None:
+        if self._peer:
+            return self._peer.display_label
+        return self._display_label
+
+    @property
+    def typename(self) -> str | None:
+        if self._peer:
+            return self._peer.typename
+        return self._typename
+
+    def _generate_input_data(self, allocate_from_pool: bool = False) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+
+        if self.is_resource_pool and allocate_from_pool:
+            return {"from_pool": {"id": self.id}}
+
+        if self.id is not None:
+            data["id"] = self.id
+        elif self.hfid is not None:
+            data["hfid"] = self.hfid
+            if self._kind is not None:
+                data["kind"] = self._kind
+
+        for prop_name in self._properties:
+            if getattr(self, prop_name) is not None:
+                data[f"_relation__{prop_name}"] = getattr(self, prop_name)
+
+        return data
+
+    def _generate_mutation_query(self) -> dict[str, Any]:
+        if self.name and self.is_resource_pool:
+            # If a related node points to a pool, ask for the ID of the pool allocated resource
+            return {self.name: {"node": {"id": None, "display_label": None, "__typename": None}}}
+        return {}
+
+    @classmethod
+    def _generate_query_data(cls, peer_data: dict[str, Any] | None = None, property: bool = False) -> dict:
+        """Generates the basic structure of a GraphQL query for a single relationship.
+
+        Args:
+            peer_data (dict[str, Union[Any, Dict]], optional): Additional data to be included in the query for the node.
+                This is used to add extra fields when prefetching related node data.
+
+        Returns:
+            Dict: A dictionary representing the basic structure of a GraphQL query, including the node's ID, display label,
+                and typename. The method also includes additional properties and any peer_data provided.
+        """
+        data: dict[str, Any] = {"node": {"id": None, "hfid": None, "display_label": None, "__typename": None}}
+        properties: dict[str, Any] = {}
+
+        if property:
+            for prop_name in PROPERTIES_FLAG:
+                properties[prop_name] = None
+            for prop_name in PROPERTIES_OBJECT:
+                properties[prop_name] = {"id": None, "display_label": None, "__typename": None}
+
+        if properties:
+            data["properties"] = properties
+        if peer_data:
+            data["node"].update(peer_data)
+
+        return data
+
+
+class RelatedNode(RelatedNodeBase):
+    """Represents a RelatedNodeBase in an asynchronous context."""
+
+    def __init__(
+        self,
+        client: InfrahubClient,
+        branch: str,
+        schema: RelationshipSchemaAPI,
+        data: Any | dict,
+        name: str | None = None,
+    ):
+        """
+        Args:
+            client (InfrahubClient): The client used to interact with the backend asynchronously.
+            branch (str): The branch where the related node resides.
+            schema (RelationshipSchema): The schema of the relationship.
+            data (Union[Any, dict]): Data representing the related node.
+            name (Optional[str]): The name of the related node.
+        """
+        self._client = client
+        super().__init__(branch=branch, schema=schema, data=data, name=name)
+
+    async def fetch(self, timeout: int | None = None) -> None:
+        if not self.id or not self.typename:
+            raise Error("Unable to fetch the peer, id and/or typename are not defined")
+
+        self._peer = await self._client.get(
+            kind=self.typename, id=self.id, populate_store=True, branch=self._branch, timeout=timeout
+        )
+
+    @property
+    def peer(self) -> InfrahubNode:
+        return self.get()
+
+    def get(self) -> InfrahubNode:
+        if self._peer:
+            return self._peer  # type: ignore[return-value]
+
+        if self.id and self.typename:
+            return self._client.store.get(key=self.id, kind=self.typename, branch=self._branch)  # type: ignore[return-value]
+
+        if self.hfid_str:
+            return self._client.store.get(key=self.hfid_str, branch=self._branch)  # type: ignore[return-value]
+
+        raise ValueError("Node must have at least one identifier (ID or HFID) to query it.")
+
+
+class RelatedNodeSync(RelatedNodeBase):
+    """Represents a related node in a synchronous context."""
+
+    def __init__(
+        self,
+        client: InfrahubClientSync,
+        branch: str,
+        schema: RelationshipSchemaAPI,
+        data: Any | dict,
+        name: str | None = None,
+    ):
+        """
+        Args:
+            client (InfrahubClientSync): The client used to interact with the backend synchronously.
+            branch (str): The branch where the related node resides.
+            schema (RelationshipSchema): The schema of the relationship.
+            data (Union[Any, dict]): Data representing the related node.
+            name (Optional[str]): The name of the related node.
+        """
+        self._client = client
+        super().__init__(branch=branch, schema=schema, data=data, name=name)
+
+    def fetch(self, timeout: int | None = None) -> None:
+        if not self.id or not self.typename:
+            raise Error("Unable to fetch the peer, id and/or typename are not defined")
+
+        self._peer = self._client.get(
+            kind=self.typename, id=self.id, populate_store=True, branch=self._branch, timeout=timeout
+        )
+
+    @property
+    def peer(self) -> InfrahubNodeSync:
+        return self.get()
+
+    def get(self) -> InfrahubNodeSync:
+        if self._peer:
+            return self._peer  # type: ignore[return-value]
+
+        if self.id and self.typename:
+            return self._client.store.get(key=self.id, kind=self.typename, branch=self._branch)  # type: ignore[return-value]
+
+        if self.hfid_str:
+            return self._client.store.get(key=self.hfid_str, branch=self._branch)  # type: ignore[return-value]
+
+        raise ValueError("Node must have at least one identifier (ID or HFID) to query it.")

infrahub_sdk/node/relationship.py

@@ -0,0 +1,302 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+from ..exceptions import (
+    UninitializedError,
+)
+from .constants import PROPERTIES_FLAG, PROPERTIES_OBJECT
+from .related_node import RelatedNode, RelatedNodeSync
+
+if TYPE_CHECKING:
+    from ..client import InfrahubClient, InfrahubClientSync
+    from ..schema import RelationshipSchemaAPI
+    from .node import InfrahubNode, InfrahubNodeSync
+
+
+class RelationshipManagerBase:
+    """Base class for RelationshipManager and RelationshipManagerSync"""
+
+    def __init__(self, name: str, branch: str, schema: RelationshipSchemaAPI):
+        """
+        Args:
+            name (str): The name of the relationship.
+            branch (str): The branch where the relationship resides.
+            schema (RelationshipSchema): The schema of the relationship.
+        """
+        self.initialized: bool = False
+        self._has_update: bool = False
+        self.name = name
+        self.schema = schema
+        self.branch = branch
+
+        self._properties_flag = PROPERTIES_FLAG
+        self._properties_object = PROPERTIES_OBJECT
+        self._properties = self._properties_flag + self._properties_object
+
+        self.peers: list[RelatedNode | RelatedNodeSync] = []
+
+    @property
+    def peer_ids(self) -> list[str]:
+        return [peer.id for peer in self.peers if peer.id]
+
+    @property
+    def peer_hfids(self) -> list[list[Any]]:
+        return [peer.hfid for peer in self.peers if peer.hfid]
+
+    @property
+    def peer_hfids_str(self) -> list[str]:
+        return [peer.hfid_str for peer in self.peers if peer.hfid_str]
+
+    @property
+    def has_update(self) -> bool:
+        return self._has_update
+
+    def _generate_input_data(self, allocate_from_pool: bool = False) -> list[dict]:
+        return [peer._generate_input_data(allocate_from_pool=allocate_from_pool) for peer in self.peers]
+
+    def _generate_mutation_query(self) -> dict[str, Any]:
+        # Does nothing for now
+        return {}
+
+    @classmethod
+    def _generate_query_data(cls, peer_data: dict[str, Any] | None = None, property: bool = False) -> dict:
+        """Generates the basic structure of a GraphQL query for relationships with multiple nodes.
+
+        Args:
+            peer_data (dict[str, Union[Any, Dict]], optional): Additional data to be included in the query for each node.
+                This is used to add extra fields when prefetching related node data in many-to-many relationships.
+
+        Returns:
+            Dict: A dictionary representing the basic structure of a GraphQL query for multiple related nodes.
+                It includes count, edges, and node information (ID, display label, and typename), along with additional properties
+                and any peer_data provided.
+        """
+        data: dict[str, Any] = {
+            "count": None,
+            "edges": {"node": {"id": None, "hfid": None, "display_label": None, "__typename": None}},
+        }
+
+        properties: dict[str, Any] = {}
+        if property:
+            for prop_name in PROPERTIES_FLAG:
+                properties[prop_name] = None
+            for prop_name in PROPERTIES_OBJECT:
+                properties[prop_name] = {"id": None, "display_label": None, "__typename": None}
+
+        if properties:
+            data["edges"]["properties"] = properties
+        if peer_data:
+            data["edges"]["node"].update(peer_data)
+
+        return data
+
+
+class RelationshipManager(RelationshipManagerBase):
+    """Manages relationships of a node in an asynchronous context."""
+
+    def __init__(
+        self,
+        name: str,
+        client: InfrahubClient,
+        node: InfrahubNode,
+        branch: str,
+        schema: RelationshipSchemaAPI,
+        data: Any | dict,
+    ):
+        """
+        Args:
+            name (str): The name of the relationship.
+            client (InfrahubClient): The client used to interact with the backend.
+            node (InfrahubNode): The node to which the relationship belongs.
+            branch (str): The branch where the relationship resides.
+            schema (RelationshipSchema): The schema of the relationship.
+            data (Union[Any, dict]): Initial data for the relationships.
+        """
+        self.client = client
+        self.node = node
+
+        super().__init__(name=name, schema=schema, branch=branch)
+
+        self.initialized = data is not None
+        self._has_update = False
+
+        if data is None:
+            return
+
+        if isinstance(data, list):
+            for item in data:
+                self.peers.append(
+                    RelatedNode(name=name, client=self.client, branch=self.branch, schema=schema, data=item)
+                )
+        elif isinstance(data, dict) and "edges" in data:
+            for item in data["edges"]:
+                self.peers.append(
+                    RelatedNode(name=name, client=self.client, branch=self.branch, schema=schema, data=item)
+                )
+        else:
+            raise ValueError(f"Unexpected format for {name} found a {type(data)}, {data}")
+
+    def __getitem__(self, item: int) -> RelatedNode:
+        return self.peers[item]  # type: ignore[return-value]
+
+    async def fetch(self) -> None:
+        if not self.initialized:
+            exclude = self.node._schema.relationship_names + self.node._schema.attribute_names
+            exclude.remove(self.schema.name)
+            node = await self.client.get(
+                kind=self.node._schema.kind,
+                id=self.node.id,
+                branch=self.branch,
+                include=[self.schema.name],
+                exclude=exclude,
+            )
+            rm = getattr(node, self.schema.name)
+            self.peers = rm.peers
+            self.initialized = True
+
+        for peer in self.peers:
+            await peer.fetch()  # type: ignore[misc]
+
+    def add(self, data: str | RelatedNode | dict) -> None:
+        """Add a new peer to this relationship."""
+        if not self.initialized:
+            raise UninitializedError("Must call fetch() on RelationshipManager before editing members")
+        new_node = RelatedNode(schema=self.schema, client=self.client, branch=self.branch, data=data)
+
+        if (new_node.id and new_node.id not in self.peer_ids) or (
+            new_node.hfid and new_node.hfid not in self.peer_hfids
+        ):
+            self.peers.append(new_node)
+            self._has_update = True
+
+    def extend(self, data: Iterable[str | RelatedNode | dict]) -> None:
+        """Add new peers to this relationship."""
+        for d in data:
+            self.add(d)
+
+    def remove(self, data: str | RelatedNode | dict) -> None:
+        if not self.initialized:
+            raise UninitializedError("Must call fetch() on RelationshipManager before editing members")
+        node_to_remove = RelatedNode(schema=self.schema, client=self.client, branch=self.branch, data=data)
+
+        if node_to_remove.id and node_to_remove.id in self.peer_ids:
+            idx = self.peer_ids.index(node_to_remove.id)
+            if self.peers[idx].id != node_to_remove.id:
+                raise IndexError(f"Unexpected situation, the node with the index {idx} should be {node_to_remove.id}")
+
+            self.peers.pop(idx)
+            self._has_update = True
+
+        elif node_to_remove.hfid and node_to_remove.hfid in self.peer_hfids:
+            idx = self.peer_hfids.index(node_to_remove.hfid)
+            if self.peers[idx].hfid != node_to_remove.hfid:
+                raise IndexError(f"Unexpected situation, the node with the index {idx} should be {node_to_remove.hfid}")
+
+            self.peers.pop(idx)
+            self._has_update = True
+
+
+class RelationshipManagerSync(RelationshipManagerBase):
+    """Manages relationships of a node in a synchronous context."""
+
+    def __init__(
+        self,
+        name: str,
+        client: InfrahubClientSync,
+        node: InfrahubNodeSync,
+        branch: str,
+        schema: RelationshipSchemaAPI,
+        data: Any | dict,
+    ):
+        """
+        Args:
+            name (str): The name of the relationship.
+            client (InfrahubClientSync): The client used to interact with the backend synchronously.
+            node (InfrahubNodeSync): The node to which the relationship belongs.
+            branch (str): The branch where the relationship resides.
+            schema (RelationshipSchema): The schema of the relationship.
+            data (Union[Any, dict]): Initial data for the relationships.
+        """
+        self.client = client
+        self.node = node
+
+        super().__init__(name=name, schema=schema, branch=branch)
+
+        self.initialized = data is not None
+        self._has_update = False
+
+        if data is None:
+            return
+
+        if isinstance(data, list):
+            for item in data:
+                self.peers.append(
+                    RelatedNodeSync(name=name, client=self.client, branch=self.branch, schema=schema, data=item)
+                )
+        elif isinstance(data, dict) and "edges" in data:
+            for item in data["edges"]:
+                self.peers.append(
+                    RelatedNodeSync(name=name, client=self.client, branch=self.branch, schema=schema, data=item)
+                )
+        else:
+            raise ValueError(f"Unexpected format for {name} found a {type(data)}, {data}")
+
+    def __getitem__(self, item: int) -> RelatedNodeSync:
+        return self.peers[item]  # type: ignore[return-value]
+
+    def fetch(self) -> None:
+        if not self.initialized:
+            exclude = self.node._schema.relationship_names + self.node._schema.attribute_names
+            exclude.remove(self.schema.name)
+            node = self.client.get(
+                kind=self.node._schema.kind,
+                id=self.node.id,
+                branch=self.branch,
+                include=[self.schema.name],
+                exclude=exclude,
+            )
+            rm = getattr(node, self.schema.name)
+            self.peers = rm.peers
+            self.initialized = True
+
+        for peer in self.peers:
+            peer.fetch()
+
+    def add(self, data: str | RelatedNodeSync | dict) -> None:
+        """Add a new peer to this relationship."""
+        if not self.initialized:
+            raise UninitializedError("Must call fetch() on RelationshipManager before editing members")
+        new_node = RelatedNodeSync(schema=self.schema, client=self.client, branch=self.branch, data=data)
+
+        if (new_node.id and new_node.id not in self.peer_ids) or (
+            new_node.hfid and new_node.hfid not in self.peer_hfids
+        ):
+            self.peers.append(new_node)
+            self._has_update = True
+
+    def extend(self, data: Iterable[str | RelatedNodeSync | dict]) -> None:
+        """Add new peers to this relationship."""
+        for d in data:
+            self.add(d)
+
+    def remove(self, data: str | RelatedNodeSync | dict) -> None:
+        if not self.initialized:
+            raise UninitializedError("Must call fetch() on RelationshipManager before editing members")
+        node_to_remove = RelatedNodeSync(schema=self.schema, client=self.client, branch=self.branch, data=data)
+
+        if node_to_remove.id and node_to_remove.id in self.peer_ids:
+            idx = self.peer_ids.index(node_to_remove.id)
+            if self.peers[idx].id != node_to_remove.id:
+                raise IndexError(f"Unexpected situation, the node with the index {idx} should be {node_to_remove.id}")
+            self.peers.pop(idx)
+            self._has_update = True
+
+        elif node_to_remove.hfid and node_to_remove.hfid in self.peer_hfids:
+            idx = self.peer_hfids.index(node_to_remove.hfid)
+            if self.peers[idx].hfid != node_to_remove.hfid:
+                raise IndexError(f"Unexpected situation, the node with the index {idx} should be {node_to_remove.hfid}")
+
+            self.peers.pop(idx)
+            self._has_update = True