infrahub-server 1.2.5__py3-none-any.whl → 1.2.7__py3-none-any.whl

infrahub_sdk/node.py

@@ -479,7 +479,7 @@ class RelationshipManagerBase:
         """
         data: dict[str, Any] = {
             "count": None,
-            "edges": {"node": {"id": None, "display_label": None, "__typename": None}},
+            "edges": {"node": {"id": None, "hfid": None, "display_label": None, "__typename": None}},
         }
 
         properties: dict[str, Any] = {}
@@ -569,7 +569,9 @@ class RelationshipManager(RelationshipManagerBase):
             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:
+        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
 
@@ -591,6 +593,14 @@ class RelationshipManager(RelationshipManagerBase):
             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."""
@@ -664,7 +674,9 @@ class RelationshipManagerSync(RelationshipManagerBase):
             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:
+        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
 
@@ -682,6 +694,13 @@ class RelationshipManagerSync(RelationshipManagerBase):
             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
@@ -793,13 +812,12 @@ class InfrahubNodeBase:
         return self.get_human_friendly_id_as_string(include_kind=True)
 
     def _init_attributes(self, data: dict | None = None) -> None:
-        for attr_name in self._attributes:
-            attr_schema = [attr for attr in self._schema.attributes if attr.name == attr_name][0]
-            attr_data = data.get(attr_name, None) if isinstance(data, dict) else None
+        for attr_schema in self._schema.attributes:
+            attr_data = data.get(attr_schema.name, None) if isinstance(data, dict) else None
             setattr(
                 self,
-                attr_name,
-                Attribute(name=attr_name, schema=attr_schema, data=attr_data),
+                attr_schema.name,
+                Attribute(name=attr_schema.name, schema=attr_schema, data=attr_data),
             )
 
     def _get_request_context(self, request_context: RequestContext | None = None) -> dict[str, Any] | None:
@@ -1147,24 +1165,23 @@ class InfrahubNode(InfrahubNodeBase):
         return cls(client=client, schema=schema, branch=branch, data=cls._strip_alias(data))
 
     def _init_relationships(self, data: dict | None = None) -> None:
-        for rel_name in self._relationships:
-            rel_schema = [rel for rel in self._schema.relationships if rel.name == rel_name][0]
-            rel_data = data.get(rel_name, None) if isinstance(data, dict) else None
+        for rel_schema in self._schema.relationships:
+            rel_data = data.get(rel_schema.name, None) if isinstance(data, dict) else None
 
             if rel_schema.cardinality == "one":
-                setattr(self, f"_{rel_name}", None)
+                setattr(self, f"_{rel_schema.name}", None)
                 setattr(
                     self.__class__,
-                    rel_name,
-                    generate_relationship_property(name=rel_name, node=self),
+                    rel_schema.name,
+                    generate_relationship_property(name=rel_schema.name, node=self),
                 )
-                setattr(self, rel_name, rel_data)
+                setattr(self, rel_schema.name, rel_data)
             else:
                 setattr(
                     self,
-                    rel_name,
+                    rel_schema.name,
                     RelationshipManager(
-                        name=rel_name,
+                        name=rel_schema.name,
                         client=self._client,
                         node=self,
                         branch=self._branch,
@@ -1679,24 +1696,23 @@ class InfrahubNodeSync(InfrahubNodeBase):
         return cls(client=client, schema=schema, branch=branch, data=cls._strip_alias(data))
 
     def _init_relationships(self, data: dict | None = None) -> None:
-        for rel_name in self._relationships:
-            rel_schema = [rel for rel in self._schema.relationships if rel.name == rel_name][0]
-            rel_data = data.get(rel_name, None) if isinstance(data, dict) else None
+        for rel_schema in self._schema.relationships:
+            rel_data = data.get(rel_schema.name, None) if isinstance(data, dict) else None
 
             if rel_schema.cardinality == "one":
-                setattr(self, f"_{rel_name}", None)
+                setattr(self, f"_{rel_schema.name}", None)
                 setattr(
                     self.__class__,
-                    rel_name,
-                    generate_relationship_property(name=rel_name, node=self),
+                    rel_schema.name,
+                    generate_relationship_property(name=rel_schema.name, node=self),
                 )
-                setattr(self, rel_name, rel_data)
+                setattr(self, rel_schema.name, rel_data)
             else:
                 setattr(
                     self,
-                    rel_name,
+                    rel_schema.name,
                     RelationshipManagerSync(
-                        name=rel_name,
+                        name=rel_schema.name,
                         client=self._client,
                         node=self,
                         branch=self._branch,

infrahub_sdk/protocols_generator/constants.py

@@ -0,0 +1,28 @@
+TEMPLATE_FILE_NAME = "template.j2"
+
+ATTRIBUTE_KIND_MAP = {
+    "ID": "String",
+    "Text": "String",
+    "TextArea": "String",
+    "DateTime": "DateTime",
+    "Email": "String",
+    "Password": "String",
+    "HashedPassword": "HashedPassword",
+    "URL": "URL",
+    "File": "String",
+    "MacAddress": "MacAddress",
+    "Color": "String",
+    "Dropdown": "Dropdown",
+    "Number": "Integer",
+    "Bandwidth": "Integer",
+    "IPHost": "IPHost",
+    "IPNetwork": "IPNetwork",
+    "Boolean": "Boolean",
+    "Checkbox": "Boolean",
+    "List": "ListAttribute",
+    "JSON": "JSONAttribute",
+    "Any": "AnyAttribute",
+}
+
+# The order of the classes in the list determines the order of the classes in the generated code
+CORE_BASE_CLASS_TO_SYNCIFY = ["CoreProfile", "CoreObjectTemplate", "CoreNode"]

infrahub_sdk/{code_generator.py → protocols_generator/generator.py}

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import Any
+from pathlib import Path
 
 import jinja2
 
-from . import protocols as sdk_protocols
-from .ctl.constants import PROTOCOLS_TEMPLATE
-from .schema import (
+from .. import protocols as sdk_protocols
+from ..schema import (
     AttributeSchemaAPI,
     GenericSchema,
     GenericSchemaAPI,
@@ -16,31 +15,22 @@ from .schema import (
     NodeSchemaAPI,
     ProfileSchemaAPI,
     RelationshipSchemaAPI,
+    TemplateSchemaAPI,
 )
+from .constants import ATTRIBUTE_KIND_MAP, CORE_BASE_CLASS_TO_SYNCIFY, TEMPLATE_FILE_NAME
 
-ATTRIBUTE_KIND_MAP = {
-    "ID": "String",
-    "Text": "String",
-    "TextArea": "String",
-    "DateTime": "DateTime",
-    "Email": "String",
-    "Password": "String",
-    "HashedPassword": "HashedPassword",
-    "URL": "URL",
-    "File": "String",
-    "MacAddress": "MacAddress",
-    "Color": "String",
-    "Dropdown": "Dropdown",
-    "Number": "Integer",
-    "Bandwidth": "Integer",
-    "IPHost": "IPHost",
-    "IPNetwork": "IPNetwork",
-    "Boolean": "Boolean",
-    "Checkbox": "Boolean",
-    "List": "ListAttribute",
-    "JSON": "JSONAttribute",
-    "Any": "AnyAttribute",
-}
+
+def load_template() -> str:
+    path = Path(__file__).parent / TEMPLATE_FILE_NAME
+    return path.read_text()
+
+
+def move_to_end_of_list(lst: list, item: str) -> list:
+    """Move an item to the end of a list if it exists in the list"""
+    if item in lst:
+        lst.remove(item)
+        lst.append(item)
+    return lst
 
 
 class CodeGenerator:
@@ -48,6 +38,7 @@ class CodeGenerator:
         self.generics: dict[str, GenericSchemaAPI | GenericSchema] = {}
         self.nodes: dict[str, NodeSchemaAPI | NodeSchema] = {}
         self.profiles: dict[str, ProfileSchemaAPI] = {}
+        self.templates: dict[str, TemplateSchemaAPI] = {}
 
         for name, schema_type in schema.items():
             if isinstance(schema_type, (GenericSchemaAPI, GenericSchema)):
@@ -56,6 +47,8 @@ class CodeGenerator:
                 self.nodes[name] = schema_type
             if isinstance(schema_type, ProfileSchemaAPI):
                 self.profiles[name] = schema_type
+            if isinstance(schema_type, TemplateSchemaAPI):
+                self.templates[name] = schema_type
 
         self.base_protocols = [
             e
@@ -71,29 +64,49 @@ class CodeGenerator:
         self.sorted_profiles = self._sort_and_filter_models(
             self.profiles, filters=["CoreProfile"] + self.base_protocols
         )
+        self.sorted_templates = self._sort_and_filter_models(
+            self.templates, filters=["CoreObjectTemplate"] + self.base_protocols
+        )
 
     def render(self, sync: bool = True) -> str:
         jinja2_env = jinja2.Environment(loader=jinja2.BaseLoader(), trim_blocks=True, lstrip_blocks=True)
-        jinja2_env.filters["inheritance"] = self._jinja2_filter_inheritance
         jinja2_env.filters["render_attribute"] = self._jinja2_filter_render_attribute
         jinja2_env.filters["render_relationship"] = self._jinja2_filter_render_relationship
+        jinja2_env.filters["syncify"] = self._jinja2_filter_syncify
 
-        template = jinja2_env.from_string(PROTOCOLS_TEMPLATE)
+        template = jinja2_env.from_string(load_template())
         return template.render(
             generics=self.sorted_generics,
             nodes=self.sorted_nodes,
             profiles=self.sorted_profiles,
+            templates=self.sorted_templates,
             base_protocols=self.base_protocols,
+            core_node_name="CoreNodeSync" if sync else "CoreNode",
             sync=sync,
         )
 
     @staticmethod
-    def _jinja2_filter_inheritance(value: dict[str, Any]) -> str:
-        inherit_from: list[str] = value.get("inherit_from", [])
+    def _jinja2_filter_syncify(value: str | list, sync: bool = False) -> str | list:
+        """Filter to help with the convertion to sync
+
+        If a string is provided, append Sync to the end of the string
+        If a list is provided, search for CoreNode and replace it with CoreNodeSync
+        """
+        if isinstance(value, list):
+            # Order the list based on the CORE_BASE_CLASS_TO_SYNCIFY list to ensure the base classes are always last
+            for item in CORE_BASE_CLASS_TO_SYNCIFY:
+                value = move_to_end_of_list(value, item)
+
+        if not sync:
+            return value
+
+        if isinstance(value, str):
+            return f"{value}Sync"
+
+        if isinstance(value, list):
+            return [f"{item}Sync" if item in CORE_BASE_CLASS_TO_SYNCIFY else item for item in value]
 
-        if not inherit_from:
-            return "CoreNode"
-        return ", ".join(inherit_from)
+        return value
 
     @staticmethod
     def _jinja2_filter_render_attribute(value: AttributeSchemaAPI) -> str:

infrahub_sdk/protocols_generator/template.j2

@@ -0,0 +1,114 @@
+#
+# Generated by "infrahubctl protocols"
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from infrahub_sdk.protocols import {{ "CoreNode" | syncify(sync) }}, {{ base_protocols | join(', ') }}
+
+if TYPE_CHECKING:
+    from infrahub_sdk.node import {{ "RelatedNode" | syncify(sync) }}, {{ "RelationshipManager" | syncify(sync) }}
+    from infrahub_sdk.protocols_base import (
+        AnyAttribute,
+        AnyAttributeOptional,
+        String,
+        StringOptional,
+        Integer,
+        IntegerOptional,
+        Boolean,
+        BooleanOptional,
+        DateTime,
+        DateTimeOptional,
+        Dropdown,
+        DropdownOptional,
+        HashedPassword,
+        HashedPasswordOptional,
+        MacAddress,
+        MacAddressOptional,
+        IPHost,
+        IPHostOptional,
+        IPNetwork,
+        IPNetworkOptional,
+        JSONAttribute,
+        JSONAttributeOptional,
+        ListAttribute,
+        ListAttributeOptional,
+        URL,
+        URLOptional,
+    )
+
+{% for generic in generics %}
+
+class {{ generic.namespace + generic.name }}({{core_node_name}}):
+    {% if not generic.attributes|default([]) and not generic.relationships|default([]) %}
+    pass
+    {% endif %}
+    {% for attribute in generic.attributes | sort(attribute='name') | default([]) %}
+    {{ attribute | render_attribute }}
+    {% endfor %}
+    {% for relationship in generic.relationships | sort(attribute='name') | default([]) %}
+    {{ relationship | render_relationship(sync) }}
+    {% endfor %}
+    {% if generic.hierarchical | default(false) %}
+    parent: {{ "RelatedNode" | syncify(sync) }}
+    children: {{ "RelationshipManager" | syncify(sync) }}
+    {% endif %}
+{% endfor %}
+
+
+{% for node in nodes %}
+
+class {{ node.namespace + node.name }}({{ node.inherit_from | syncify(sync) | join(", ") or core_node_name }}):
+    {% if not node.attributes|default([]) and not node.relationships|default([]) %}
+    pass
+    {% endif %}
+    {% for attribute in node.attributes | sort(attribute='name') | default([]) %}
+    {{ attribute | render_attribute }}
+    {% endfor %}
+    {% for relationship in node.relationships | sort(attribute='name') | default([]) %}
+    {{ relationship | render_relationship(sync) }}
+    {% endfor %}
+    {% if node.hierarchical | default(false) %}
+    parent: {{ "RelatedNode" | syncify(sync) }}
+    children: {{ "RelationshipManager" | syncify(sync) }}
+    {% endif %}
+
+{% endfor %}
+
+
+{% for node in profiles %}
+
+class {{ node.namespace + node.name }}({{ node.inherit_from | syncify(sync) | join(", ") or core_node_name }}):
+    {% if not node.attributes|default([]) and not node.relationships|default([]) %}
+    pass
+    {% endif %}
+    {% for attribute in node.attributes | sort(attribute='name') | default([]) %}
+    {{ attribute | render_attribute }}
+    {% endfor %}
+    {% for relationship in node.relationships | sort(attribute='name') | default([]) %}
+    {{ relationship | render_relationship(sync) }}
+    {% endfor %}
+    {% if node.hierarchical | default(false) %}
+    parent: {{ "RelatedNode" | syncify(sync) }}
+    children: {{ "RelationshipManager" | syncify(sync) }}
+    {% endif %}
+
+{% endfor %}
+
+
+{% for node in templates %}
+
+class {{ node.namespace + node.name }}({{ node.inherit_from | syncify(sync) | join(", ") or core_node_name }}):
+    {% if not node.attributes|default([]) and not node.relationships|default([]) %}
+    pass
+    {% endif %}
+    {% for attribute in node.attributes | sort(attribute='name') | default([]) %}
+    {{ attribute | render_attribute }}
+    {% endfor %}
+    {% for relationship in node.relationships | sort(attribute='name') | default([]) %}
+    {{ relationship | render_relationship(sync) }}
+    {% endfor %}
+
+{% endfor %}