infrahub-server 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

infrahub_sdk/node.py

@@ -15,7 +15,7 @@ from .exceptions import (
 )
 from .graphql import Mutation, Query
 from .schema import GenericSchemaAPI, RelationshipCardinality, RelationshipKind
-from .utils import compare_lists, get_flat_value
+from .utils import compare_lists, generate_short_id, get_flat_value
 from .uuidt import UUIDT
 
 if TYPE_CHECKING:
@@ -43,6 +43,20 @@ ARTIFACT_DEFINITION_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE = (
     "calling generate is only supported for CoreArtifactDefinition nodes"
 )
 
+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}")
+
 
 class Attribute:
     """Represents an attribute of a Node, including its schema, value, and properties."""
@@ -340,10 +354,10 @@ class RelatedNode(RelatedNodeBase):
             return self._peer  # type: ignore[return-value]
 
         if self.id and self.typename:
-            return self._client.store.get(key=self.id, kind=self.typename)  # type: ignore[return-value]
+            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_by_hfid(key=self.hfid_str)  # type: ignore[return-value]
+            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.")
 
@@ -387,10 +401,10 @@ class RelatedNodeSync(RelatedNodeBase):
             return self._peer  # type: ignore[return-value]
 
         if self.id and self.typename:
-            return self._client.store.get(key=self.id, kind=self.typename)  # type: ignore[return-value]
+            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_by_hfid(key=self.hfid_str)  # type: ignore[return-value]
+            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.")
 
@@ -678,6 +692,11 @@ class InfrahubNodeBase:
         self._branch = branch
         self._existing: bool = True
 
+        # Generate a unique ID only to be used inside the SDK
+        # The format if this ID is purposely different from the ID used by the API
+        # This is done to avoid confusion and potential conflicts between the IDs
+        self._internal_id = generate_short_id()
+
         self.id = data.get("id", None) if isinstance(data, dict) else None
         self.display_label: str | None = data.get("display_label", None) if isinstance(data, dict) else None
         self.typename: str | None = data.get("__typename", schema.kind) if isinstance(data, dict) else schema.kind
@@ -694,6 +713,9 @@ class InfrahubNodeBase:
         self._init_attributes(data)
         self._init_relationships(data)
 
+    def get_branch(self) -> str:
+        return self._branch
+
     def get_path_value(self, path: str) -> Any:
         path_parts = path.split("__")
         return_value = None
@@ -794,6 +816,11 @@ class InfrahubNodeBase:
     def get_kind(self) -> str:
         return self._schema.kind
 
+    def get_all_kinds(self) -> list[str]:
+        if hasattr(self._schema, "inherit_from"):
+            return [self._schema.kind] + self._schema.inherit_from
+        return [self._schema.kind]
+
     def is_ip_prefix(self) -> bool:
         builtin_ipprefix_kind = "BuiltinIPPrefix"
         return self.get_kind() == builtin_ipprefix_kind or builtin_ipprefix_kind in self._schema.inherit_from  # type: ignore[union-attr]
@@ -1201,7 +1228,7 @@ class InfrahubNode(InfrahubNodeBase):
         else:
             await self._client.group_context.add_related_nodes(ids=[self.id], update_group_context=update_group_context)
 
-        self._client.store.set(key=self.id, node=self)
+        self._client.store.set(node=self)
 
     async def generate_query_data(
         self,
@@ -1418,8 +1445,10 @@ class InfrahubNode(InfrahubNodeBase):
     ) -> None:
         mutation_query = self._generate_mutation_query()
 
+        # Upserting means we may want to create, meaning payload contains all mandatory fields required for a creation,
+        # so hfid is just redondant information. Currently, upsert mutation has performance overhead if `hfid` is filled.
         if allow_upsert:
-            input_data = self._generate_input_data(exclude_hfid=False, request_context=request_context)
+            input_data = self._generate_input_data(exclude_hfid=True, request_context=request_context)
             mutation_name = f"{self._schema.kind}Upsert"
             tracker = f"mutation-{str(self._schema.kind).lower()}-upsert"
         else:
@@ -1477,15 +1506,15 @@ class InfrahubNode(InfrahubNodeBase):
         for rel_name in self._relationships:
             rel = getattr(self, rel_name)
             if rel and isinstance(rel, RelatedNode):
-                relation = node_data["node"].get(rel_name)
-                if relation.get("node", None):
+                relation = node_data["node"].get(rel_name, None)
+                if relation and relation.get("node", None):
                     related_node = await InfrahubNode.from_graphql(
                         client=self._client, branch=branch, data=relation, timeout=timeout
                     )
                     related_nodes.append(related_node)
             elif rel and isinstance(rel, RelationshipManager):
-                peers = node_data["node"].get(rel_name)
-                if peers:
+                peers = node_data["node"].get(rel_name, None)
+                if peers and peers["edges"]:
                     for peer in peers["edges"]:
                         related_node = await InfrahubNode.from_graphql(
                             client=self._client, branch=branch, data=peer, timeout=timeout
@@ -1724,7 +1753,7 @@ class InfrahubNodeSync(InfrahubNodeBase):
         else:
             self._client.group_context.add_related_nodes(ids=[self.id], update_group_context=update_group_context)
 
-        self._client.store.set(key=self.id, node=self)
+        self._client.store.set(node=self)
 
     def generate_query_data(
         self,

infrahub_sdk/protocols_base.py

@@ -144,7 +144,8 @@ class AnyAttributeOptional(Attribute):
 @runtime_checkable
 class CoreNodeBase(Protocol):
     _schema: MainSchemaTypes
-    id: str
+    _internal_id: str
+    id: str  # NOTE this is incorrect, should be str | None
     display_label: str | None
 
     @property
@@ -153,10 +154,16 @@ class CoreNodeBase(Protocol):
     @property
     def hfid_str(self) -> str | None: ...
 
+    def get_human_friendly_id(self) -> list[str] | None: ...
+
     def get_human_friendly_id_as_string(self, include_kind: bool = False) -> str | None: ...
 
     def get_kind(self) -> str: ...
 
+    def get_all_kinds(self) -> list[str]: ...
+
+    def get_branch(self) -> str: ...
+
     def is_ip_prefix(self) -> bool: ...
 
     def is_ip_address(self) -> bool: ...

infrahub_sdk/pytest_plugin/items/jinja2_transform.py

@@ -1,51 +1,47 @@
 from __future__ import annotations
 
+import asyncio
 import difflib
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 import jinja2
 import ujson
 from httpx import HTTPStatusError
-from rich.console import Console
-from rich.traceback import Traceback
 
-from ...jinja2 import identify_faulty_jinja_code
-from ..exceptions import Jinja2TransformError, Jinja2TransformUndefinedError, OutputMatchError
+from ...template import Jinja2Template
+from ...template.exceptions import JinjaTemplateError
+from ..exceptions import OutputMatchError
 from ..models import InfrahubInputOutputTest, InfrahubTestExpectedResult
 from .base import InfrahubItem
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
     from pytest import ExceptionInfo
 
 
 class InfrahubJinja2Item(InfrahubItem):
+    def _get_jinja2(self) -> Jinja2Template:
+        return Jinja2Template(
+            template=Path(self.resource_config.template_path),  # type: ignore[attr-defined]
+            template_directory=Path(self.session.infrahub_config_path.parent),  # type: ignore[attr-defined]
+        )
+
     def get_jinja2_environment(self) -> jinja2.Environment:
-        loader = jinja2.FileSystemLoader(self.session.infrahub_config_path.parent)  # type: ignore[attr-defined]
-        return jinja2.Environment(loader=loader, trim_blocks=True, lstrip_blocks=True)
+        jinja2_template = self._get_jinja2()
+        return jinja2_template.get_environment()
 
     def get_jinja2_template(self) -> jinja2.Template:
-        return self.get_jinja2_environment().get_template(str(self.resource_config.template_path))  # type: ignore[attr-defined]
+        jinja2_template = self._get_jinja2()
+        return jinja2_template.get_template()
 
     def render_jinja2_template(self, variables: dict[str, Any]) -> str | None:
+        jinja2_template = self._get_jinja2()
+
         try:
-            return self.get_jinja2_template().render(**variables)
-        except jinja2.UndefinedError as exc:
-            traceback = Traceback(show_locals=False)
-            errors = identify_faulty_jinja_code(traceback=traceback)
-            console = Console()
-            with console.capture() as capture:
-                console.print(f"An error occurred while rendering Jinja2 transform:{self.name!r}\n", soft_wrap=True)
-                console.print(f"{exc.message}\n", soft_wrap=True)
-                for frame, syntax in errors:
-                    console.print(f"{frame.filename} on line {frame.lineno}\n", soft_wrap=True)
-                    console.print(syntax, soft_wrap=True)
-            str_output = capture.get()
+            return asyncio.run(jinja2_template.render(variables=variables))
+        except JinjaTemplateError as exc:
             if self.test.expect == InfrahubTestExpectedResult.PASS:
-                raise Jinja2TransformUndefinedError(
-                    name=self.name, message=str_output, rtb=traceback, errors=errors
-                ) from exc
+                raise exc
             return None
 
     def get_result_differences(self, computed: Any) -> str | None:
@@ -99,8 +95,8 @@ class InfrahubJinja2TransformUnitRenderItem(InfrahubJinja2Item):
             raise OutputMatchError(name=self.name, differences=differences)
 
     def repr_failure(self, excinfo: ExceptionInfo, style: str | None = None) -> str:
-        if isinstance(excinfo.value, (Jinja2TransformUndefinedError, Jinja2TransformError)):
-            return excinfo.value.message
+        if isinstance(excinfo.value, (JinjaTemplateError)):
+            return str(excinfo.value.message)
 
         return super().repr_failure(excinfo, style=style)