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

infrahub/core/schema/schema_branch_display.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import hashlib
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from infrahub.core.schema import SchemaAttributePath
+
+
+@dataclass
+class TemplateLabel:
+    template: str
+    attributes: set[str] = field(default_factory=set)
+    relationships: set[str] = field(default_factory=set)
+    filter_key: str = "ids"
+
+    @property
+    def fields(self) -> list[str]:
+        return sorted(list(self.attributes) + list(self.relationships))
+
+    @property
+    def has_related_components(self) -> bool:
+        """Indicate if the associated template use variables from relationships"""
+        return len(self.relationships) > 0
+
+    def get_hash(self) -> str:
+        return hashlib.md5(self.template.encode(), usedforsecurity=False).hexdigest()
+
+
+@dataclass
+class RelationshipIdentifier:
+    kind: str
+    filter_key: str
+    template: str
+
+    def __hash__(self) -> int:
+        return hash(f"{self.kind}::{self.filter_key}::{self.template}")
+
+
+@dataclass
+class RelationshipTriggers:
+    attributes: dict[str, set[RelationshipIdentifier]] = field(default_factory=dict)
+
+
+class DisplayLabels:
+    def __init__(
+        self,
+        template_based_display_labels: dict[str, TemplateLabel] | None = None,
+        template_relationship_triggers: dict[str, RelationshipTriggers] | None = None,
+    ) -> None:
+        self._template_based_display_labels: dict[str, TemplateLabel] = template_based_display_labels or {}
+        self._template_relationship_triggers: dict[str, RelationshipTriggers] = template_relationship_triggers or {}
+
+    def duplicate(self) -> DisplayLabels:
+        """Clone the current object."""
+        return self.__class__(
+            template_based_display_labels=deepcopy(self._template_based_display_labels),
+            template_relationship_triggers=deepcopy(self._template_relationship_triggers),
+        )
+
+    def register_attribute_based_display_label(self, kind: str, attribute_name: str) -> None:
+        """Register nodes where the display label consists of a single defined attribute name."""
+        self._template_based_display_labels[kind] = TemplateLabel(
+            template=f"{{{{ {attribute_name}__value }}}}", attributes={attribute_name}
+        )
+
+    def register_template_schema_path(self, kind: str, schema_path: SchemaAttributePath, template: str) -> None:
+        """Register Jinja2 template based display labels using the schema path of each impacted variable in the node."""
+
+        if kind not in self._template_based_display_labels:
+            self._template_based_display_labels[kind] = TemplateLabel(template=template)
+
+        if schema_path.is_type_attribute:
+            self._template_based_display_labels[kind].attributes.add(schema_path.active_attribute_schema.name)
+        elif schema_path.is_type_relationship and schema_path.related_schema:
+            self._template_based_display_labels[kind].relationships.add(schema_path.active_relationship_schema.name)
+            if schema_path.related_schema.kind not in self._template_relationship_triggers:
+                self._template_relationship_triggers[schema_path.related_schema.kind] = RelationshipTriggers()
+            if (
+                schema_path.active_attribute_schema.name
+                not in self._template_relationship_triggers[schema_path.related_schema.kind].attributes
+            ):
+                self._template_relationship_triggers[schema_path.related_schema.kind].attributes[
+                    schema_path.active_attribute_schema.name
+                ] = set()
+            self._template_relationship_triggers[schema_path.related_schema.kind].attributes[
+                schema_path.active_attribute_schema.name
+            ].add(
+                RelationshipIdentifier(
+                    kind=kind, filter_key=f"{schema_path.active_relationship_schema.name}__ids", template=template
+                )
+            )
+
+    def targets_node(self, kind: str) -> bool:
+        """Indicates if there is a display_label defined for the targeted node"""
+        return kind in self._template_based_display_labels
+
+    def get_template_node(self, kind: str) -> TemplateLabel:
+        """Return node kinds together with their template definitions."""
+        return self._template_based_display_labels[kind]
+
+    def get_template_nodes(self) -> dict[str, TemplateLabel]:
+        """Return node kinds together with their template definitions."""
+        return self._template_based_display_labels
+
+    def get_related_trigger_nodes(self) -> dict[str, RelationshipTriggers]:
+        """Return node kinds that other nodes use within their templates for display_labels."""
+        return self._template_relationship_triggers
+
+    def get_related_template(self, related_kind: str, target_kind: str) -> TemplateLabel:
+        relationship_trigger = self._template_relationship_triggers[related_kind]
+        for applicable_kinds in relationship_trigger.attributes.values():
+            for relationship_identifier in applicable_kinds:
+                if target_kind == relationship_identifier.kind:
+                    template_label = self.get_template_node(kind=target_kind)
+                    template_label.filter_key = relationship_identifier.filter_key
+                    return template_label
+
+        raise ValueError(
+            f"Unable to find registered template for {target_kind} registered on related node {related_kind}"
+        )

infrahub/core/schema/schema_branch_hfid.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import hashlib
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from infrahub.core.schema import SchemaAttributePath
+
+
+@dataclass
+class HFIDDefinition:
+    hfid: list[str]
+    attributes: set[str] = field(default_factory=set)
+    relationships: set[str] = field(default_factory=set)
+    filter_key: str = "ids"
+
+    @property
+    def fields(self) -> list[str]:
+        return sorted(list(self.attributes) + list(self.relationships))
+
+    @property
+    def has_related_components(self) -> bool:
+        """Indicate if the associated template use variables from relationships"""
+        return len(self.relationships) > 0
+
+    def get_hash(self) -> str:
+        return hashlib.md5("::".join(self.hfid).encode(), usedforsecurity=False).hexdigest()
+
+
+@dataclass
+class RelationshipIdentifier:
+    kind: str
+    hfid: list[str]
+    filter_key: str
+
+    def __hash__(self) -> int:
+        return hash(f"{self.kind}::{'::'.join(self.hfid)}::{self.filter_key}")
+
+
+@dataclass
+class RelationshipTriggers:
+    attributes: dict[str, set[RelationshipIdentifier]] = field(default_factory=dict)
+
+
+class HFIDs:
+    def __init__(
+        self,
+        node_level_hfids: dict[str, HFIDDefinition] | None = None,
+        relationship_triggers: dict[str, RelationshipTriggers] | None = None,
+    ) -> None:
+        self._node_level_hfids: dict[str, HFIDDefinition] = node_level_hfids or {}
+        self._relationship_triggers: dict[str, RelationshipTriggers] = relationship_triggers or {}
+
+    def duplicate(self) -> HFIDs:
+        return self.__class__(
+            node_level_hfids=deepcopy(self._node_level_hfids),
+            relationship_triggers=deepcopy(self._relationship_triggers),
+        )
+
+    def register_hfid_schema_path(self, kind: str, schema_path: SchemaAttributePath, hfid: list[str]) -> None:
+        """Register HFID using the schema path of each impacted schema path in use."""
+        if kind not in self._node_level_hfids:
+            self._node_level_hfids[kind] = HFIDDefinition(hfid=hfid)
+        if schema_path.is_type_attribute:
+            self._node_level_hfids[kind].attributes.add(schema_path.active_attribute_schema.name)
+        elif schema_path.is_type_relationship and schema_path.related_schema:
+            self._node_level_hfids[kind].relationships.add(schema_path.active_relationship_schema.name)
+            if schema_path.related_schema.kind not in self._relationship_triggers:
+                self._relationship_triggers[schema_path.related_schema.kind] = RelationshipTriggers()
+            if (
+                schema_path.active_attribute_schema.name
+                not in self._relationship_triggers[schema_path.related_schema.kind].attributes
+            ):
+                self._relationship_triggers[schema_path.related_schema.kind].attributes[
+                    schema_path.active_attribute_schema.name
+                ] = set()
+            self._relationship_triggers[schema_path.related_schema.kind].attributes[
+                schema_path.active_attribute_schema.name
+            ].add(
+                RelationshipIdentifier(
+                    kind=kind, filter_key=f"{schema_path.active_relationship_schema.name}__ids", hfid=hfid
+                )
+            )
+
+    def targets_node(self, kind: str) -> bool:
+        """Indicates if there is a human_friendly_id defined for the targeted node"""
+        return kind in self._node_level_hfids
+
+    def get_node_definition(self, kind: str) -> HFIDDefinition:
+        """Return node kinds together with their template definitions."""
+        return self._node_level_hfids[kind]
+
+    def get_template_nodes(self) -> dict[str, HFIDDefinition]:
+        """Return node kinds together with their template definitions."""
+        return self._node_level_hfids
+
+    def get_related_trigger_nodes(self) -> dict[str, RelationshipTriggers]:
+        """Return node kinds that other nodes use within their templates for display_labels."""
+        return self._relationship_triggers
+
+    def get_related_definition(self, related_kind: str, target_kind: str) -> HFIDDefinition:
+        relationship_trigger = self._relationship_triggers[related_kind]
+        for applicable_kinds in relationship_trigger.attributes.values():
+            for relationship_identifier in applicable_kinds:
+                if target_kind == relationship_identifier.kind:
+                    template_label = self.get_node_definition(kind=target_kind)
+                    template_label.filter_key = relationship_identifier.filter_key
+                    return template_label
+
+        raise ValueError(
+            f"Unable to find registered template for {target_kind} registered on related node {related_kind}"
+        )

infrahub/core/validators/aggregated_checker.py

@@ -49,7 +49,7 @@ class AggregatedConstraintChecker:
                 node_display_label = None
                 display_label = None
                 if node:
-                    node_display_label = await node.render_display_label(db=self.db)
+                    node_display_label = await node.get_display_label(db=self.db)
                 if node_display_label:
                     if request.node_schema.display_labels and node:
                         display_label = f"Node {node_display_label} ({node.get_kind()}: {path.node_id})"

infrahub/core/validators/determiner.py

@@ -10,6 +10,7 @@ from infrahub.core.schema.attribute_parameters import AttributeParameters
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.schema.schema_branch import SchemaBranch
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
+from infrahub.exceptions import SchemaNotFoundError
 from infrahub.log import get_logger
 
 if TYPE_CHECKING:
@@ -81,7 +82,17 @@ class ConstraintValidatorDeterminer:
 
     async def _get_all_property_constraints(self) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
-        for schema in self.schema_branch.get_all().values():
+        schemas = list(self.schema_branch.get_all(duplicate=False).values())
+        # added here to check their uniqueness constraints
+        try:
+            schemas.append(self.schema_branch.get_node(name="SchemaAttribute", duplicate=False))
+        except SchemaNotFoundError:
+            pass
+        try:
+            schemas.append(self.schema_branch.get_node(name="SchemaRelationship", duplicate=False))
+        except SchemaNotFoundError:
+            pass
+        for schema in schemas:
             constraints.extend(await self._get_property_constraints_for_one_schema(schema=schema))
         return constraints
 

infrahub/core/validators/relationship/peer.py

@@ -22,7 +22,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
     name = "relationship_constraints_peer_validator"
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
-        peer_schema = db.schema.get(name=self.relationship_schema.peer, branch=self.branch)
+        peer_schema = db.schema.get(name=self.relationship_schema.peer, branch=self.branch, duplicate=False)
         allowed_peer_kinds = [peer_schema.kind]
         if isinstance(peer_schema, GenericSchema):
             allowed_peer_kinds += peer_schema.used_by

infrahub/core/validators/tasks.py

@@ -36,7 +36,7 @@ async def schema_validate_migrations(message: SchemaValidateMigrationData) -> li
     log.info(f"{len(message.constraints)} constraint(s) to validate")
     # NOTE this task is a good candidate to add a progress bar
     for constraint in message.constraints:
-        schema = message.schema_branch.get(name=constraint.path.schema_kind)
+        schema = message.schema_branch.get(name=constraint.path.schema_kind, duplicate=False)
         if not isinstance(schema, GenericSchema | NodeSchema):
             continue
         batch.add(

infrahub/display_labels/gather.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from prefect import task
+from prefect.cache_policies import NONE
+from prefect.logging import get_run_logger
+
+from infrahub.core.registry import registry
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+
+from .models import DisplayLabelTriggerDefinition
+
+
+@dataclass
+class BranchScope:
+    name: str
+    out_of_scope: list[str] = field(default_factory=list)
+
+
+@task(
+    name="gather-trigger-display-labels-jinja2",
+    cache_policy=NONE,
+)
+async def gather_trigger_display_labels_jinja2(
+    db: InfrahubDatabase | None = None,  # noqa: ARG001 Needed to have a common function signature for gathering functions
+) -> list[DisplayLabelTriggerDefinition]:
+    log = get_run_logger()
+
+    # Build a list of all branches to process based on which branch is different from main
+    branches_with_diff_from_main = registry.get_altered_schema_branches()
+    branches_to_process: list[BranchScope] = [BranchScope(name=branch) for branch in branches_with_diff_from_main]
+    branches_to_process.append(BranchScope(name=registry.default_branch, out_of_scope=branches_with_diff_from_main))
+
+    triggers: list[DisplayLabelTriggerDefinition] = []
+
+    for branch in branches_to_process:
+        schema_branch = registry.schema.get_schema_branch(name=branch.name)
+        branch_triggers = DisplayLabelTriggerDefinition.from_schema_display_labels(
+            branch=branch.name,
+            display_labels=schema_branch.display_labels,
+            branches_out_of_scope=branch.out_of_scope,
+        )
+        log.info(f"Generating {len(branch_triggers)} Jinja2 trigger for {branch.name} (except {branch.out_of_scope})")
+
+        triggers.extend(branch_triggers)
+
+    return triggers

infrahub/display_labels/models.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Self
+
+from infrahub_sdk.graphql import Query
+from pydantic import BaseModel, Field
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.registry import registry
+from infrahub.core.schema import NodeSchema  # noqa: TC001
+from infrahub.events import NodeUpdatedEvent
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import (
+    EventTrigger,
+    ExecuteWorkflow,
+    TriggerBranchDefinition,
+    TriggerType,
+)
+from infrahub.workflows.catalogue import DISPLAY_LABELS_PROCESS_JINJA2
+
+if TYPE_CHECKING:
+    from infrahub.core.schema.schema_branch_display import DisplayLabels, RelationshipTriggers
+
+
+@dataclass
+class AttributeTarget:
+    hash: str
+    fields: set[str]
+
+
+class DisplayLabelTriggerDefinition(TriggerBranchDefinition):
+    type: TriggerType = TriggerType.DISPLAY_LABEL_JINJA2
+    template_hash: str
+    target_kind: str | None = Field(default=None)
+
+    def get_description(self) -> str:
+        return f"{super().get_description()} | hash:{self.template_hash}"
+
+    @classmethod
+    def from_schema_display_labels(
+        cls,
+        branch: str,
+        display_labels: DisplayLabels,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> list[DisplayLabelTriggerDefinition]:
+        """
+        This function is used to create a trigger definition for a display labels of type Jinja2.
+        """
+
+        definitions: list[DisplayLabelTriggerDefinition] = []
+
+        for node_kind, template_label in display_labels.get_template_nodes().items():
+            definitions.append(
+                cls.new(
+                    branch=branch,
+                    node_kind=node_kind,
+                    target_kind=node_kind,
+                    fields=[
+                        "_trigger_placeholder"
+                    ],  # Triggers for the nodes themselves are only used to determine if all nodes should be regenerated
+                    template_hash=template_label.get_hash(),
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        for related_kind, relationship_trigger in display_labels.get_related_trigger_nodes().items():
+            definitions.extend(
+                cls.from_related_node(
+                    branch=branch,
+                    related_kind=related_kind,
+                    relationship_trigger=relationship_trigger,
+                    display_labels=display_labels,
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        return definitions
+
+    @classmethod
+    def from_related_node(
+        cls,
+        branch: str,
+        related_kind: str,
+        relationship_trigger: RelationshipTriggers,
+        display_labels: DisplayLabels,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> list[DisplayLabelTriggerDefinition]:
+        targets_by_attribute: dict[str, AttributeTarget] = {}
+        definitions: list[DisplayLabelTriggerDefinition] = []
+        for attribute, relationship_identifiers in relationship_trigger.attributes.items():
+            for relationship_identifier in relationship_identifiers:
+                actual_node = display_labels.get_template_node(kind=relationship_identifier.kind)
+                if relationship_identifier.kind not in targets_by_attribute:
+                    targets_by_attribute[relationship_identifier.kind] = AttributeTarget(
+                        actual_node.get_hash(), fields=set()
+                    )
+                targets_by_attribute[relationship_identifier.kind].fields.add(attribute)
+
+        for target_kind, attribute_target in targets_by_attribute.items():
+            definitions.append(
+                cls.new(
+                    branch=branch,
+                    node_kind=related_kind,
+                    target_kind=target_kind,
+                    fields=sorted(attribute_target.fields),
+                    template_hash=attribute_target.hash,
+                    branches_out_of_scope=branches_out_of_scope,
+                )
+            )
+
+        return definitions
+
+    @classmethod
+    def new(
+        cls,
+        branch: str,
+        node_kind: str,
+        target_kind: str,
+        template_hash: str,
+        fields: list[str],
+        branches_out_of_scope: list[str] | None = None,
+    ) -> Self:
+        event_trigger = EventTrigger()
+        event_trigger.events.add(NodeUpdatedEvent.event_name)
+        event_trigger.match = {"infrahub.node.kind": node_kind}
+        if branches_out_of_scope:
+            event_trigger.match["infrahub.branch.name"] = [f"!{branch}" for branch in branches_out_of_scope]
+        elif not branches_out_of_scope and branch != registry.default_branch:
+            event_trigger.match["infrahub.branch.name"] = branch
+
+        event_trigger.match_related = {
+            "prefect.resource.role": ["infrahub.node.attribute_update", "infrahub.node.relationship_update"],
+            "infrahub.field.name": fields,
+        }
+
+        workflow = ExecuteWorkflow(
+            workflow=DISPLAY_LABELS_PROCESS_JINJA2,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "node_kind": node_kind,
+                "object_id": "{{ event.resource['infrahub.node.id'] }}",
+                "target_kind": target_kind,
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {
+                        "__prefect_kind": "jinja",
+                        "template": "{{ event.payload['context'] | tojson }}",
+                    },
+                },
+            },
+        )
+
+        trigger_definition_target_kind = target_kind if target_kind == node_kind else None
+
+        return cls(
+            name=f"{target_kind}{NAME_SEPARATOR}by{NAME_SEPARATOR}{node_kind}",
+            template_hash=template_hash,
+            branch=branch,
+            trigger=event_trigger,
+            actions=[workflow],
+            target_kind=trigger_definition_target_kind,
+        )
+
+
+class DisplayLabelJinja2GraphQLResponse(BaseModel):
+    node_id: str
+    display_label_value: str | None
+    variables: dict[str, Any] = Field(default_factory=dict)
+
+
+class DisplayLabelJinja2GraphQL(BaseModel):
+    filter_key: str
+    node_schema: NodeSchema = Field(..., description="The node kind where the computed attribute is defined")
+    variables: list[str] = Field(..., description="The list of variable names used within the computed attribute")
+
+    def render_graphql_query(self, filter_id: str) -> str:
+        query_fields = self.query_fields
+        query_fields["id"] = None
+        query_fields["display_label"] = None
+        query = Query(
+            name="DisplayLabelFilter",
+            query={
+                self.node_schema.kind: {
+                    "@filters": {self.filter_key: filter_id},
+                    "edges": {"node": query_fields},
+                }
+            },
+        )
+
+        return query.render()
+
+    @property
+    def query_fields(self) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            if field_name in self.node_schema.attribute_names:
+                output[field_name] = {remainder: None}
+            elif field_name in self.node_schema.relationship_names:
+                related_attribute, related_value = remainder.split("__", maxsplit=1)
+                relationship = self.node_schema.get_relationship(name=field_name)
+                if relationship.cardinality == RelationshipCardinality.ONE:
+                    if field_name not in output:
+                        output[field_name] = {"node": {}}
+                    output[field_name]["node"][related_attribute] = {related_value: None}
+        return output
+
+    def parse_response(self, response: dict[str, Any]) -> list[DisplayLabelJinja2GraphQLResponse]:
+        rendered_response: list[DisplayLabelJinja2GraphQLResponse] = []
+        if kind_payload := response.get(self.node_schema.kind):
+            edges = kind_payload.get("edges", [])
+            for node in edges:
+                if node_response := self.to_node_response(node_dict=node):
+                    rendered_response.append(node_response)
+        return rendered_response
+
+    def to_node_response(self, node_dict: dict[str, Any]) -> DisplayLabelJinja2GraphQLResponse | None:
+        if node := node_dict.get("node"):
+            node_id = node.get("id")
+        else:
+            return None
+
+        display_label = node.get("display_label")
+        response = DisplayLabelJinja2GraphQLResponse(node_id=node_id, display_label_value=display_label)
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            response.variables[variable] = None
+            if field_content := node.get(field_name):
+                if field_name in self.node_schema.attribute_names:
+                    response.variables[variable] = field_content.get(remainder)
+                elif field_name in self.node_schema.relationship_names:
+                    relationship = self.node_schema.get_relationship(name=field_name)
+                    if relationship.cardinality == RelationshipCardinality.ONE:
+                        related_attribute, related_value = remainder.split("__", maxsplit=1)
+                        node_content = field_content.get("node") or {}
+                        related_attribute_content = node_content.get(related_attribute) or {}
+                        response.variables[variable] = related_attribute_content.get(related_value)
+
+        return response