infrahub-server 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

infrahub_sdk/ctl/cli_commands.py

@@ -9,7 +9,6 @@ import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
-import jinja2
 import typer
 import ujson
 from rich.console import Console
@@ -18,7 +17,6 @@ from rich.logging import RichHandler
 from rich.panel import Panel
 from rich.pretty import Pretty
 from rich.table import Table
-from rich.traceback import Traceback
 
 from .. import __version__ as sdk_version
 from ..async_typer import AsyncTyper
@@ -31,7 +29,7 @@ from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.generator import run as run_generator
 from ..ctl.menu import app as menu_app
 from ..ctl.object import app as object_app
-from ..ctl.render import list_jinja2_transforms
+from ..ctl.render import list_jinja2_transforms, print_template_errors
 from ..ctl.repository import app as repository_app
 from ..ctl.repository import get_repository_config
 from ..ctl.schema import app as schema_app
@@ -44,8 +42,9 @@ from ..ctl.utils import (
 )
 from ..ctl.validate import app as validate_app
 from ..exceptions import GraphQLError, ModuleImportError
-from ..jinja2 import identify_faulty_jinja_code
 from ..schema import MainSchemaTypesAll, SchemaRoot
+from ..template import Jinja2Template
+from ..template.exceptions import JinjaTemplateError
 from ..utils import get_branch, write_to_file
 from ..yaml import SchemaFile
 from .exporter import dump
@@ -168,43 +167,28 @@ async def run(
         raise typer.Abort(f"Unable to Load the method {method} in the Python script at {script}")
 
     client = initialize_client(
-        branch=branch, timeout=timeout, max_concurrent_execution=concurrent, identifier=module_name
+        branch=branch,
+        timeout=timeout,
+        max_concurrent_execution=concurrent,
+        identifier=module_name,
     )
     func = getattr(module, method)
     await func(client=client, log=log, branch=branch, **variables_dict)
 
 
-def render_jinja2_template(template_path: Path, variables: dict[str, str], data: dict[str, Any]) -> str:
-    if not template_path.is_file():
-        console.print(f"[red]Unable to locate the template at {template_path}")
-        raise typer.Exit(1)
-
-    templateLoader = jinja2.FileSystemLoader(searchpath=".")
-    templateEnv = jinja2.Environment(loader=templateLoader, trim_blocks=True, lstrip_blocks=True)
-    template = templateEnv.get_template(str(template_path))
-
+async def render_jinja2_template(template_path: Path, variables: dict[str, Any], data: dict[str, Any]) -> str:
+    variables["data"] = data
+    jinja_template = Jinja2Template(template=Path(template_path), template_directory=Path())
     try:
-        rendered_tpl = template.render(**variables, data=data)  # type: ignore[arg-type]
-    except jinja2.TemplateSyntaxError as exc:
-        console.print("[red]Syntax Error detected on the template")
-        console.print(f"[yellow]  {exc}")
-        raise typer.Exit(1) from exc
-
-    except jinja2.UndefinedError as exc:
-        console.print("[red]An error occurred while rendering the jinja template")
-        traceback = Traceback(show_locals=False)
-        errors = identify_faulty_jinja_code(traceback=traceback)
-        for frame, syntax in errors:
-            console.print(f"[yellow]{frame.filename} on line {frame.lineno}\n")
-            console.print(syntax)
-        console.print("")
-        console.print(traceback.trace.stacks[0].exc_value)
+        rendered_tpl = await jinja_template.render(variables=variables)
+    except JinjaTemplateError as exc:
+        print_template_errors(error=exc, console=console)
         raise typer.Exit(1) from exc
 
     return rendered_tpl
 
 
-def _run_transform(
+async def _run_transform(
     query_name: str,
     variables: dict[str, Any],
     transform_func: Callable,
@@ -227,7 +211,11 @@ def _run_transform(
 
     try:
         response = execute_graphql_query(
-            query=query_name, variables_dict=variables, branch=branch, debug=debug, repository_config=repository_config
+            query=query_name,
+            variables_dict=variables,
+            branch=branch,
+            debug=debug,
+            repository_config=repository_config,
         )
 
         # TODO: response is a dict and can't be printed to the console in this way.
@@ -249,7 +237,7 @@ def _run_transform(
         raise typer.Abort()
 
     if asyncio.iscoroutinefunction(transform_func):
-        output = asyncio.run(transform_func(response))
+        output = await transform_func(response)
     else:
         output = transform_func(response)
     return output
@@ -257,7 +245,7 @@ def _run_transform(
 
 @app.command(name="render")
 @catch_exception(console=console)
-def render(
+async def render(
     transform_name: str = typer.Argument(default="", help="Name of the Python transformation", show_default=False),
     variables: Optional[list[str]] = typer.Argument(
         None, help="Variables to pass along with the query. Format key=value key=value."
@@ -289,7 +277,7 @@ def render(
     transform_func = functools.partial(render_jinja2_template, transform_config.template_path, variables_dict)
 
     # Query GQL and run the transform
-    result = _run_transform(
+    result = await _run_transform(
         query_name=transform_config.query,
         variables=variables_dict,
         transform_func=transform_func,
@@ -410,7 +398,10 @@ def version() -> None:
 
 @app.command(name="info")
 @catch_exception(console=console)
-def info(detail: bool = typer.Option(False, help="Display detailed information."), _: str = CONFIG_PARAM) -> None:  # noqa: PLR0915
+def info(  # noqa: PLR0915
+    detail: bool = typer.Option(False, help="Display detailed information."),
+    _: str = CONFIG_PARAM,
+) -> None:
     """Display the status of the Python SDK."""
 
     info: dict[str, Any] = {
@@ -476,10 +467,14 @@ def info(detail: bool = typer.Option(False, help="Display detailed information."
         infrahub_info = Table(show_header=False, box=None)
         if info["user_info"]:
             infrahub_info.add_row("User:", info["user_info"]["AccountProfile"]["display_label"])
-            infrahub_info.add_row("Description:", info["user_info"]["AccountProfile"]["description"]["value"])
+            infrahub_info.add_row(
+                "Description:",
+                info["user_info"]["AccountProfile"]["description"]["value"],
+            )
             infrahub_info.add_row("Status:", info["user_info"]["AccountProfile"]["status"]["label"])
             infrahub_info.add_row(
-                "Number of Groups:", str(info["user_info"]["AccountProfile"]["member_of_groups"]["count"])
+                "Number of Groups:",
+                str(info["user_info"]["AccountProfile"]["member_of_groups"]["count"]),
             )
 
             if groups := info["groups"]:

infrahub_sdk/ctl/render.py

@@ -1,6 +1,12 @@
 from rich.console import Console
 
 from ..schema.repository import InfrahubRepositoryConfig
+from ..template.exceptions import (
+    JinjaTemplateError,
+    JinjaTemplateNotFoundError,
+    JinjaTemplateSyntaxError,
+    JinjaTemplateUndefinedError,
+)
 
 
 def list_jinja2_transforms(config: InfrahubRepositoryConfig) -> None:
@@ -9,3 +15,36 @@ def list_jinja2_transforms(config: InfrahubRepositoryConfig) -> None:
 
     for transform in config.jinja2_transforms:
         console.print(f"{transform.name} ({transform.template_path})")
+
+
+def print_template_errors(error: JinjaTemplateError, console: Console) -> None:
+    if isinstance(error, JinjaTemplateNotFoundError):
+        console.print("[red]An error occurred while rendering the jinja template")
+        console.print("")
+        if error.base_template:
+            console.print(f"Base template: [yellow]{error.base_template}")
+        console.print(f"Missing template: [yellow]{error.filename}")
+        return
+
+    if isinstance(error, JinjaTemplateUndefinedError):
+        console.print("[red]An error occurred while rendering the jinja template")
+        for current_error in error.errors:
+            console.print(f"[yellow]{current_error.frame.filename} on line {current_error.frame.lineno}\n")
+            console.print(current_error.syntax)
+        console.print("")
+        console.print(error.message)
+        return
+
+    if isinstance(error, JinjaTemplateSyntaxError):
+        console.print("[red]A syntax error was encountered within the template")
+        console.print("")
+        if error.filename:
+            console.print(f"Filename: [yellow]{error.filename}")
+        console.print(f"Line number: [yellow]{error.lineno}")
+        console.print()
+        console.print(error.message)
+        return
+
+    console.print("[red]An error occurred while rendering the jinja template")
+    console.print("")
+    console.print(f"[yellow]{error.message}")

infrahub_sdk/exceptions.py

@@ -69,12 +69,12 @@ class ModuleImportError(Error):
 class NodeNotFoundError(Error):
     def __init__(
         self,
-        node_type: str,
         identifier: Mapping[str, list[str]],
         message: str = "Unable to find the node in the database.",
         branch_name: str | None = None,
+        node_type: str | None = None,
     ):
-        self.node_type = node_type
+        self.node_type = node_type or "unknown"
         self.identifier = identifier
         self.branch_name = branch_name
 
@@ -88,6 +88,10 @@ class NodeNotFoundError(Error):
         """
 
 
+class NodeInvalidError(NodeNotFoundError):
+    pass
+
+
 class ResourceNotDefinedError(Error):
     """Raised when trying to access a resource that hasn't been defined."""
 

infrahub_sdk/generator.py

@@ -137,7 +137,7 @@ class InfrahubGenerator:
 
         for node in self._nodes + self._related_nodes:
             if node.id:
-                self._init_client.store.set(key=node.id, node=node)
+                self._init_client.store.set(node=node)
 
     @abstractmethod
     async def generate(self, data: dict) -> None:

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,
@@ -1479,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
@@ -1726,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)
 

infrahub_sdk/schema/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 from collections.abc import MutableMapping
 from enum import Enum
 from time import sleep
@@ -13,6 +14,7 @@ from typing_extensions import TypeAlias
 
 from ..exceptions import (
     InvalidResponseError,
+    JsonDecodeError,
     SchemaNotFoundError,
     ValidationError,
 )
@@ -420,7 +422,14 @@ class InfrahubSchema(InfrahubSchemaBase):
         response = await self.client._get(url=url, timeout=timeout)
         response.raise_for_status()
 
-        data: MutableMapping[str, Any] = response.json()
+        try:
+            data: MutableMapping[str, Any] = response.json()
+        except json.decoder.JSONDecodeError as exc:
+            raise JsonDecodeError(
+                message=f"Invalid Schema response received from the server at {response.url}: {response.text} [{response.status_code}] ",
+                content=response.text,
+                url=response.url,
+            ) from exc
 
         nodes: MutableMapping[str, MainSchemaTypesAPI] = {}
         for node_schema in data.get("nodes", []):