infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/core/node/node_property_attribute.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from infrahub_sdk.template import Jinja2Template
+
+from infrahub.core.query.node import AttributeFromDB
+from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
+
+from ..attribute import BaseAttribute, ListAttributeOptional, StringOptional
+
+if TYPE_CHECKING:
+    from infrahub.core.node import Node
+    from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
+    from infrahub.core.schema.attribute_schema import AttributeSchema
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+T = TypeVar("T")
+
+
+class NodePropertyAttribute(Generic[T]):
+    """A node property attribute is a construct that seats between a property and an attribute.
+
+    View it as a property, set at the node level but stored in the database as an attribute. It usually is something computed from other components of
+    a node, such as its attributes and its relationships.
+    """
+
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: T | None,
+        value: AttributeFromDB | T | None = None,
+    ) -> None:
+        self.node_schema = node_schema
+
+        self.node_attributes: list[str] = []
+        self.node_relationships: list[str] = []
+
+        self.template = template
+        self._value = value
+        self._manually_assigned = False
+
+        self.schema: AttributeSchema
+
+        self.analyze_variables()
+
+    def needs_update(self, fields: list[str] | None) -> bool:
+        """Tell if this node property attribute must be recomputed given a list of updated fields of a node."""
+        if self._manually_assigned or not fields:
+            return True
+        for field in fields:
+            if field in self.node_attributes or field in self.node_relationships:
+                return True
+
+        return False
+
+    @property
+    def attribute_value(self) -> AttributeFromDB | dict[str, T | None]:
+        if isinstance(self._value, AttributeFromDB):
+            return self._value
+        return {"value": self._value}
+
+    def set_value(self, value: T | None, manually_assigned: bool = False) -> None:
+        """Force the value of the node property attribute to the given one."""
+        if isinstance(self._value, AttributeFromDB):
+            self._value.value = value
+        else:
+            self._value = value
+
+        if manually_assigned:
+            self._manually_assigned = True
+
+    def get_value(self, node: Node, at: Timestamp) -> T | None:
+        if isinstance(self._value, AttributeFromDB):
+            attr = self.get_node_attribute(node=node, at=at)
+            return attr.value  # type: ignore
+
+        return self._value
+
+    @abstractmethod
+    def analyze_variables(self) -> None: ...
+
+    @abstractmethod
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None: ...
+
+    @abstractmethod
+    def get_node_attribute(self, node: Node, at: Timestamp) -> BaseAttribute: ...
+
+
+class DisplayLabel(NodePropertyAttribute[str]):
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: str | None,
+        value: AttributeFromDB | str | None = None,
+    ) -> None:
+        super().__init__(node_schema=node_schema, template=template, value=value)
+
+        self.schema = node_schema.get_attribute(name="display_label")
+
+    @property
+    def is_jinja2_template(self) -> bool:
+        if self.template is None:
+            return False
+
+        return any(c in self.template for c in "{}")
+
+    def _analyze_plain_value(self) -> None:
+        if self.template is None or "__" not in self.template:
+            return
+
+        items = self.template.split("__", maxsplit=1)
+        if items[0] not in self.node_schema.attribute_names:
+            raise ValueError(f"{items[0]} is not an attribute of {self.node_schema.kind}")
+
+        self.node_attributes.append(items[0])
+
+    def _analyze_jinja2_value(self) -> None:
+        if self.template is None or not self.is_jinja2_template:
+            return
+
+        tpl = Jinja2Template(template=self.template)
+        for variable in tpl.get_variables():
+            items = variable.split("__", maxsplit=1)
+            if items[0] in self.node_schema.attribute_names:
+                self.node_attributes.append(items[0])
+            elif items[0] in self.node_schema.relationship_names:
+                self.node_relationships.append(items[0])
+            else:
+                raise ValueError(f"{items[0]} is neither an attribute or a relationship of {self.node_schema.kind}")
+
+    def analyze_variables(self) -> None:
+        """Look at variables used in the display label and record attributes and relationships required to compute it."""
+        if not self.is_jinja2_template:
+            self._analyze_plain_value()
+        else:
+            self._analyze_jinja2_value()
+
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None:
+        """Update the display label value by recomputing it from the template."""
+        if self.template is None or self._manually_assigned:
+            return
+
+        if node.get_schema() != self.node_schema:
+            raise ValueError(
+                f"display_label for schema {self.node_schema.kind} cannot be rendered for node {node.get_schema().kind} {node.id}"
+            )
+
+        if not self.is_jinja2_template:
+            path_value = await node.get_path_value(db=db, path=self.template)
+            # Use .value for enum to keep compat with old style display label
+            self.set_value(value=str(path_value if not isinstance(path_value, Enum) else path_value.value))
+            return
+
+        jinja2_template = Jinja2Template(template=self.template)
+
+        variables: dict[str, Any] = {}
+        for variable in jinja2_template.get_variables():
+            variables[variable] = await node.get_path_value(db=db, path=variable)
+
+        self.set_value(value=await jinja2_template.render(variables=variables))
+
+    def get_node_attribute(self, node: Node, at: Timestamp) -> StringOptional:
+        """Return a node attribute that can be stored in the database for this display label and node."""
+        return StringOptional(
+            name="display_label",
+            schema=self.schema,
+            branch=node.get_branch(),
+            at=at,
+            node=node,
+            data=self.attribute_value,
+        )
+
+
+class HumanFriendlyIdentifier(NodePropertyAttribute[list[str]]):
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: list[str] | None,
+        value: AttributeFromDB | list[str] | None = None,
+    ) -> None:
+        super().__init__(node_schema=node_schema, template=template, value=value)
+
+        self.schema = node_schema.get_attribute(name="human_friendly_id")
+
+    def _analyze_single_variable(self, value: str) -> None:
+        items = value.split("__", maxsplit=1)
+        if items[0] in self.node_schema.attribute_names:
+            self.node_attributes.append(items[0])
+        elif items[0] in self.node_schema.relationship_names:
+            self.node_relationships.append(items[0])
+        else:
+            raise ValueError(f"{items[0]} is neither an attribute or a relationship of {self.node_schema.kind}")
+
+    def analyze_variables(self) -> None:
+        """Look at variables used in the HFID and record attributes and relationships required to compute it."""
+        for item in self.template or []:
+            self._analyze_single_variable(value=item)
+
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None:
+        """Update the HFID value by recomputing it from the template."""
+        if self.template is None or self._manually_assigned:
+            return
+
+        if node.get_schema() != self.node_schema:
+            raise ValueError(
+                f"human_friendly_id for schema {self.node_schema.kind} cannot be computed for node {node.get_schema().kind} {node.id}"
+            )
+
+        value: list[str] = []
+        for path in self.template:
+            path_value = await node.get_path_value(db=db, path=path)
+            # Use .value for enum to be consistent with display label
+            value.append(path_value if not isinstance(path_value, Enum) else path_value.value)
+
+        self.set_value(value=value)
+
+    def get_node_attribute(self, node: Node, at: Timestamp) -> ListAttributeOptional:
+        """Return a node attribute that can be stored in the database for this HFID and node."""
+        return ListAttributeOptional(
+            name="human_friendly_id",
+            schema=self.schema,
+            branch=node.get_branch(),
+            at=at,
+            node=node,
+            data=self.attribute_value,
+        )

infrahub/core/node/standard.py

@@ -111,7 +111,7 @@ class StandardNode(BaseModel):
         node = result.get("n")
 
         self.id = node.element_id
-        self.uuid = node["uuid"]
+        self.uuid = UUID(node["uuid"])
 
         return True
 

infrahub/core/property.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from enum import Enum
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -26,6 +27,10 @@ class NodePropertyData(BaseModel):
     peer_id: str
 
 
+class ClearValue(Enum):
+    CLEAR = "clear"
+
+
 class FlagPropertyMixin:
     _flag_properties: list[str] = [v.value for v in FlagProperty]
 
@@ -51,6 +56,7 @@ class NodePropertyMixin:
         for node in self._node_properties:
             setattr(self, f"_{node}", None)
             setattr(self, f"{node}_id", None)
+            setattr(self, f"_clear_{node}", False)
 
         if not kwargs:
             return
@@ -79,12 +85,14 @@ class NodePropertyMixin:
 
     def clear_owner(self) -> None:
         self._set_node_property(name="owner", value=None)
+        self._clear_owner = True
 
     async def get_source(self, db: InfrahubDatabase) -> Node | None:
         return await self._get_node_property(name="source", db=db)
 
     def clear_source(self) -> None:
         self._set_node_property(name="source", value=None)
+        self._clear_source = True
 
     def set_source(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="source", value=value)
@@ -95,6 +103,9 @@ class NodePropertyMixin:
     def set_owner(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="owner", value=value)
 
+    def is_clear(self, name: str) -> bool:
+        return getattr(self, f"_clear_{name}", False)
+
     def _get_node_property_from_cache(self, name: str) -> Node:
         """Return the node attribute if it's already present locally,
         Otherwise raise an exception

infrahub/core/protocols.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from .protocols_base import CoreNode
+from infrahub.core.protocols_base import CoreNode
 
 if TYPE_CHECKING:
     from enum import Enum
@@ -125,6 +125,7 @@ class CoreGenericRepository(CoreNode):
     queries: RelationshipManager
     checks: RelationshipManager
     generators: RelationshipManager
+    groups_objects: RelationshipManager
 
 
 class CoreGroup(CoreNode):
@@ -349,6 +350,10 @@ class CoreGeneratorAction(CoreAction):
     generator: RelationshipManager
 
 
+class CoreGeneratorAwareGroup(CoreGroup):
+    pass
+
+
 class CoreGeneratorCheck(CoreCheck):
     instance: String
 
@@ -360,6 +365,8 @@ class CoreGeneratorDefinition(CoreTaskTarget):
     file_path: String
     class_name: String
     convert_query_response: BooleanOptional
+    execute_in_proposed_change: BooleanOptional
+    execute_after_merge: BooleanOptional
     query: RelationshipManager
     repository: RelationshipManager
     targets: RelationshipManager

infrahub/core/query/attribute.py

@@ -133,7 +133,7 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
     def __init__(
         self,
         prop_name: str,
-        prop_id: str,
+        prop_id: str | None = None,
         **kwargs: Any,
     ):
         self.prop_name = prop_name
@@ -144,6 +144,8 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         at = self.at or self.attr.at
 
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=at)
+        self.params.update(branch_params)
         self.params["attr_uuid"] = self.attr.id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
@@ -151,18 +153,34 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
         self.params["prop_name"] = self.prop_name
         self.params["prop_id"] = self.prop_id
 
-        rel_name = f"HAS_{self.prop_name.upper()}"
+        rel_label = f"HAS_{self.prop_name.upper()}"
 
-        query = (
+        if self.branch.is_default or self.branch.is_global:
+            node_query = """
+        MATCH (np:Node { uuid: $prop_id })-[r:IS_PART_OF]->(:Root)
+        WHERE r.branch IN $branch0
+        AND r.status = "active"
+        AND r.from <= $at AND (r.to IS NULL OR r.to > $at)
+        WITH np
+        LIMIT 1
             """
+        else:
+            node_query = """
+        MATCH (np:Node { uuid: $prop_id })-[r:IS_PART_OF]->(:Root)
+        WHERE %(branch_filter)s
+        ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+        LIMIT 1
+        WITH np
+        WHERE r.status = "active"
+            """ % {"branch_filter": branch_filter}
+        self.add_to_query(node_query)
+
+        attr_query = """
         MATCH (a:Attribute { uuid: $attr_uuid })
-        MATCH (np:Node { uuid: $prop_id })
-        CREATE (a)-[r:%s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(np)
-        """
-            % rel_name
-        )
+        CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(np)
+        """ % {"rel_label": rel_label}
+        self.add_to_query(attr_query)
 
-        self.add_to_query(query)
         self.return_labels = ["a", "np", "r"]
 
 
@@ -204,7 +222,6 @@ async def default_attribute_query_filter(
     param_prefix: str | None = None,
     db: InfrahubDatabase | None = None,  # noqa: ARG001
     partial_match: bool = False,
-    support_profiles: bool = False,
 ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
     """Generate Query String Snippet to filter the right node."""
     attribute_value_label = GraphAttributeValueNode.get_default_label()
@@ -251,9 +268,6 @@ async def default_attribute_query_filter(
                 query_where.append(f"toString(av.{filter_name}) =~ ${param_prefix}_{filter_name}")
             elif filter_name == "isnull":
                 query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
-            elif support_profiles:
-                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
-                query_where.append(f"(av.{filter_name} = ${param_prefix}_{filter_name} OR av.is_default)")
             else:
                 query_filter.append(
                     QueryNode(
@@ -271,8 +285,6 @@ async def default_attribute_query_filter(
         if attribute_kind and attribute_kind == "List":
             query_params[f"{param_prefix}_{filter_name}"] = build_regex_attrs(values=filter_value)
             query_where.append(f"toString(av.value) =~ ${param_prefix}_{filter_name}")
-        elif support_profiles:
-            query_where.append(f"(av.value IN ${param_prefix}_value OR av.is_default)")
         else:
             query_where.append(f"av.value IN ${param_prefix}_value")
         query_params[f"{param_prefix}_value"] = filter_value