infrahub-server 1.3.0a0__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

infrahub/graphql/mutations/resource_manager.py

@@ -6,15 +6,17 @@ from graphene import Boolean, Field, InputField, InputObjectType, Int, List, Mut
 from graphene.types.generic import GenericScalar
 from typing_extensions import Self
 
-from infrahub.core import registry
+from infrahub.core import protocols, registry
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.ipam.constants import PrefixMemberType
+from infrahub.core.manager import NodeManager
 from infrahub.core.schema import NodeSchema
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.database import retry_db_transaction
 from infrahub.exceptions import QueryValidationError, SchemaNotFoundError, ValidationError
 
 from ..queries.resource_manager import PoolAllocatedNode
-from .main import InfrahubMutationMixin, InfrahubMutationOptions
+from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -177,14 +179,16 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
-            pool_node = registry.schema.get(name=data["node"].value)
-            if not pool_node.is_generic_schema and not pool_node.is_node_schema:
+            schema_node = registry.schema.get(name=data["node"].value)
+            if not schema_node.is_generic_schema and not schema_node.is_node_schema:
                 raise ValidationError(input_value="The selected model is not a Node or a Generic")
         except SchemaNotFoundError as exc:
             exc.message = "The selected model does not exist"
             raise exc
 
-        attributes = [attribute for attribute in pool_node.attributes if attribute.name == data["node_attribute"].value]
+        attributes = [
+            attribute for attribute in schema_node.attributes if attribute.name == data["node_attribute"].value
+        ]
         if not attributes:
             raise ValidationError(input_value="The selected attribute doesn't exist in the selected model")
 
@@ -192,9 +196,22 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         if attribute.kind != "Number":
             raise ValidationError(input_value="The selected attribute is not of the kind Number")
 
-        if data["start_range"].value > data["end_range"].value:
+        start_range = data["start_range"].value
+        end_range = data["end_range"].value
+        if start_range > end_range:
             raise ValidationError(input_value="start_range can't be larger than end_range")
 
+        if not isinstance(attribute.parameters, NumberAttributeParameters):
+            raise ValidationError(
+                input_value="The selected attribute parameters are not of the kind NumberAttributeParameters"
+            )
+
+        if attribute.parameters.min_value is not None and start_range < attribute.parameters.min_value:
+            raise ValidationError(input_value="start_range can't be less than min_value")
+
+        if attribute.parameters.max_value is not None and end_range > attribute.parameters.max_value:
+            raise ValidationError(input_value="end_range can't be larger than max_value")
+
         return await super().mutate_create(info=info, data=data, branch=branch)
 
     @classmethod
@@ -221,3 +238,42 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
                 raise ValidationError(input_value="start_range can't be larger than end_range")
 
         return number_pool, result
+
+    @classmethod
+    @retry_db_transaction(name="resource_manager_update")
+    async def mutate_delete(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+    ) -> DeleteResult:
+        graphql_context: GraphqlContext = info.context
+
+        number_pool = await NodeManager.find_object(
+            db=graphql_context.db,
+            kind=protocols.CoreNumberPool,
+            id=data.get("id"),
+            hfid=data.get("hfid"),
+            branch=branch,
+        )
+
+        active_branches = registry.schema.get_branches()
+        violating_branches = []
+        for active_branch in active_branches:
+            try:
+                schema = registry.schema.get(name=number_pool.node.value, branch=active_branch)
+            except SchemaNotFoundError:
+                continue
+
+            if number_pool.node_attribute.value in schema.attribute_names:
+                attribute = schema.get_attribute(name=number_pool.node_attribute.value)
+                if attribute.kind == "NumberPool":
+                    violating_branches.append(active_branch)
+
+        if violating_branches:
+            raise ValidationError(
+                input_value=f"Unable to delete number pool {number_pool.node.value}.{number_pool.node_attribute.value}"
+                f" is in use (branches: {','.join(violating_branches)})"
+            )
+
+        return await super().mutate_delete(info=info, data=data, branch=branch)

infrahub/graphql/queries/resource_manager.py

@@ -306,7 +306,13 @@ async def resolve_number_pool_allocation(
 async def resolve_number_pool_utilization(
     db: InfrahubDatabase, pool: CoreNode, at: Timestamp | str | None, branch: Branch
 ) -> dict:
-    number_pool = NumberUtilizationGetter(db=db, pool=pool, at=at, branch=branch)
+    """
+    Returns a mapping containg utilization info of a number pool.
+    The utilization is calculated as the percentage of the total number of values in the pool that are not excluded for the corresponding attribute.
+    """
+
+    core_number_pool = await registry.manager.get_one_by_id_or_default_filter(db=db, id=pool.id, kind="CoreNumberPool")
+    number_pool = NumberUtilizationGetter(db=db, pool=core_number_pool, at=at, branch=branch)
     await number_pool.load_data()
 
     return {

infrahub/graphql/queries/task.py

@@ -32,6 +32,8 @@ class Tasks(ObjectType):
         workflow: list[str] | None = None,
         related_node__ids: list | None = None,
         q: str | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         related_nodes = related_node__ids or []
         ids = ids or []
@@ -45,6 +47,8 @@ class Tasks(ObjectType):
             statuses=state,
             workflows=workflow,
             related_nodes=related_nodes,
+            log_limit=log_limit,
+            log_offset=log_offset,
         )
 
     @staticmethod
@@ -71,6 +75,8 @@ class Tasks(ObjectType):
         branch: str | None = None,
         limit: int | None = None,
         offset: int | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         graphql_context: GraphqlContext = info.context
         fields = await extract_fields_first_node(info)
@@ -87,6 +93,8 @@ class Tasks(ObjectType):
             related_nodes=related_nodes,
             limit=limit,
             offset=offset,
+            log_limit=log_limit,
+            log_offset=log_offset,
         )
         prefect_count = prefect_tasks.get("count", None)
         return {
@@ -105,6 +113,8 @@ Task = Field(
     workflow=List(String),
     ids=List(String),
     q=String(required=False),
+    log_limit=Int(required=False),
+    log_offset=Int(required=False),
     resolver=Tasks.resolve,
     required=True,
 )

infrahub/graphql/types/task_log.py

@@ -1,4 +1,4 @@
-from graphene import Field, InputObjectType, List, ObjectType, String
+from graphene import Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene.types.uuid import UUID
 
 from .enums import Severity
@@ -26,4 +26,5 @@ class TaskLogNodes(ObjectType):
 
 
 class TaskLogEdge(ObjectType):
-    edges = List(TaskLogNodes)
+    edges = List(NonNull(TaskLogNodes), required=True)
+    count = Int(required=True)

infrahub/menu/menu.py

@@ -249,7 +249,7 @@ default_menu = [
             MenuItemDefinition(
                 namespace="Builtin",
                 name="TriggerDefinition",
-                label="Triggers",
+                label="Events",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -258,7 +258,7 @@ default_menu = [
                     MenuItemDefinition(
                         namespace="Core",
                         name="TriggerRule",
-                        label="Trigger Rules",
+                        label="Rules",
                         kind=InfrahubKind.TRIGGERRULE,
                         icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
                         protected=True,
@@ -268,7 +268,7 @@ default_menu = [
                     MenuItemDefinition(
                         namespace="Core",
                         name="Action",
-                        label="Trigger Actions",
+                        label="Actions",
                         kind=InfrahubKind.ACTION,
                         icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.ACTION)),
                         protected=True,

infrahub/pools/number.py

@@ -8,7 +8,7 @@ from infrahub.core.registry import registry
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
-    from infrahub.core.protocols import CoreNode
+    from infrahub.core.node.resource_manager.number_pool import CoreNumberPool
     from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
@@ -20,7 +20,9 @@ class UsedNumber:
 
 
 class NumberUtilizationGetter:
-    def __init__(self, db: InfrahubDatabase, pool: CoreNode, branch: Branch, at: Timestamp | str | None = None) -> None:
+    def __init__(
+        self, db: InfrahubDatabase, pool: CoreNumberPool, branch: Branch, at: Timestamp | str | None = None
+    ) -> None:
         self.db = db
         self.at = at
         self.pool = pool
@@ -62,4 +64,4 @@ class NumberUtilizationGetter:
 
     @property
     def total_pool_size(self) -> int:
-        return self.end_range - self.start_range + 1
+        return self.end_range - self.start_range + 1 - self.pool.get_attribute_nb_excluded_values()

infrahub/task_manager/task.py

@@ -35,6 +35,9 @@ from .models import FlowLogs, FlowProgress, RelatedNodesInfo
 
 log = get_logger()
 
+NB_LOGS_LIMIT = 10_000
+PREFECT_MAX_LOGS_PER_CALL = 200
+
 
 class PrefectTask:
     @classmethod
@@ -83,9 +86,42 @@ class PrefectTask:
         return related_nodes
 
     @classmethod
-    async def _get_logs(cls, client: PrefectClient, flow_ids: list[UUID]) -> FlowLogs:
+    async def _get_logs(
+        cls, client: PrefectClient, flow_ids: list[UUID], log_limit: int | None, log_offset: int | None
+    ) -> FlowLogs:
+        """
+        Return the logs for a flow run, based on log_limit and log_offset.
+        At most, NB_LOGS_LIMIT logs will be returned per flow.
+        """
+
         logs_flow = FlowLogs()
-        all_logs = await client.read_logs(log_filter=LogFilter(flow_run_id=LogFilterFlowRunId(any_=flow_ids)))
+
+        log_limit = log_limit if log_limit is not None else NB_LOGS_LIMIT
+        log_offset = log_offset or 0
+        current_offset = log_offset
+
+        if log_limit > NB_LOGS_LIMIT:
+            raise ValueError(f"log_limit cannot be greater than {NB_LOGS_LIMIT}")
+
+        all_logs = []
+
+        # Fetch the logs in batches of PREFECT_MAX_LOGS_PER_CALL, as prefect does not allow to fetch more logs at once.
+        remaining = min(log_limit, NB_LOGS_LIMIT)
+        while remaining > 0:
+            batch_limit = min(PREFECT_MAX_LOGS_PER_CALL, remaining)
+            logs_batch = await client.read_logs(
+                log_filter=LogFilter(flow_run_id=LogFilterFlowRunId(any_=flow_ids)),
+                offset=current_offset,
+                limit=batch_limit,
+            )
+            all_logs.extend(logs_batch)
+            nb_fetched = len(logs_batch)
+            if nb_fetched < batch_limit:
+                break  # No more logs to fetch
+
+            current_offset += nb_fetched
+            remaining -= nb_fetched
+
         for flow_log in all_logs:
             if flow_log.flow_run_id and flow_log.message not in ["Finished in state Completed()"]:
                 logs_flow.logs[flow_log.flow_run_id].append(flow_log)
@@ -188,6 +224,8 @@ class PrefectTask:
         branch: str | None = None,
         limit: int | None = None,
         offset: int | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         nodes: list[dict] = []
         count = None
@@ -219,7 +257,9 @@ class PrefectTask:
                     sort=FlowRunSort.START_TIME_DESC,
                 )
                 if log_fields:
-                    logs_flow = await cls._get_logs(client=client, flow_ids=[flow.id for flow in flows])
+                    logs_flow = await cls._get_logs(
+                        client=client, flow_ids=[flow.id for flow in flows], log_limit=log_limit, log_offset=log_offset
+                    )
 
                 if "progress" in node_fields:
                     progress_flow = await cls._get_progress(client=client, flow_ids=[flow.id for flow in flows])
@@ -265,7 +305,7 @@ class PrefectTask:
                                 "updated_at": flow.updated.to_iso8601_string(),  # type: ignore
                                 "start_time": flow.start_time.to_iso8601_string() if flow.start_time else None,
                                 "id": flow.id,
-                                "logs": {"edges": logs},
+                                "logs": {"edges": logs, "count": len(logs)},
                             }
                         }
                     )

infrahub/types.py

@@ -235,6 +235,10 @@ class Number(InfrahubDataType):
     infrahub = "Integer"
 
 
+class NumberPool(Number):
+    label: str = "Number Pool"
+
+
 class Bandwidth(InfrahubDataType):
     label: str = "Bandwidth"
     graphql = graphene.Int
@@ -329,6 +333,7 @@ ATTRIBUTE_TYPES: dict[str, type[InfrahubDataType]] = {
     "MacAddress": MacAddress,
     "Color": Color,
     "Number": Number,
+    "NumberPool": NumberPool,
     "Bandwidth": Bandwidth,
     "IPHost": IPHost,
     "IPNetwork": IPNetwork,
@@ -353,6 +358,7 @@ ATTRIBUTE_PYTHON_TYPES: dict[str, type] = {
     "MacAddress": str,  # MAC addresses can be straightforward strings
     "Color": str,  # Colors often represented as hex strings
     "Number": float,  # Numbers can be floats for general use
+    "NumberPool": float,  # Numbers can be floats for general use
     "Bandwidth": float,  # Bandwidth in some units, represented as a float
     "IPHost": IPvAnyAddress,  # type: ignore[dict-item]
     "IPNetwork": str,

infrahub_sdk/client.py

@@ -172,11 +172,18 @@ class BaseClient:
         params: dict[str, Any] | None = None,
         delete_unused_nodes: bool = False,
         group_type: str | None = None,
+        group_params: dict[str, Any] | None = None,
+        branch: str | None = None,
     ) -> Self:
         self.mode = InfrahubClientMode.TRACKING
         identifier = identifier or self.identifier or "python-sdk"
         self.set_context_properties(
-            identifier=identifier, params=params, delete_unused_nodes=delete_unused_nodes, group_type=group_type
+            identifier=identifier,
+            params=params,
+            delete_unused_nodes=delete_unused_nodes,
+            group_type=group_type,
+            group_params=group_params,
+            branch=branch,
         )
         return self
 
@@ -187,14 +194,22 @@ class BaseClient:
         delete_unused_nodes: bool = True,
         reset: bool = True,
         group_type: str | None = None,
+        group_params: dict[str, Any] | None = None,
+        branch: str | None = None,
     ) -> None:
         if reset:
             if isinstance(self, InfrahubClient):
                 self.group_context = InfrahubGroupContext(self)
             elif isinstance(self, InfrahubClientSync):
                 self.group_context = InfrahubGroupContextSync(self)
+
         self.group_context.set_properties(
-            identifier=identifier, params=params, delete_unused_nodes=delete_unused_nodes, group_type=group_type
+            identifier=identifier,
+            params=params,
+            delete_unused_nodes=delete_unused_nodes,
+            group_type=group_type,
+            group_params=group_params,
+            branch=branch,
         )
 
     def _graphql_url(
@@ -562,18 +577,27 @@ class InfrahubClient(BaseClient):
         at: Timestamp | None = None,
         branch: str | None = None,
         timeout: int | None = None,
+        partial_match: bool = False,
         **kwargs: Any,
     ) -> int:
         """Return the number of nodes of a given kind."""
-        filters = kwargs
-        schema = await self.schema.get(kind=kind, branch=branch)
+        filters: dict[str, Any] = dict(kwargs)
 
+        if partial_match:
+            filters["partial_match"] = True
+
+        schema = await self.schema.get(kind=kind, branch=branch)
         branch = branch or self.default_branch
         if at:
             at = Timestamp(at)
 
+        data: dict[str, Any] = {
+            "count": None,
+            "@filters": filters,
+        }
+
         response = await self.execute_graphql(
-            query=Query(query={schema.kind: {"count": None, "@filters": filters}}).render(),
+            query=Query(query={schema.kind: data}).render(),
             branch_name=branch,
             at=at,
             timeout=timeout,
@@ -801,7 +825,7 @@ class InfrahubClient(BaseClient):
             nodes = []
             related_nodes = []
             batch_process = await self.create_batch()
-            count = await self.count(kind=schema.kind, **filters)
+            count = await self.count(kind=schema.kind, partial_match=partial_match, **filters)
             total_pages = (count + pagination_size - 1) // pagination_size
 
             for page_number in range(1, total_pages + 1):
@@ -1683,18 +1707,27 @@ class InfrahubClientSync(BaseClient):
         at: Timestamp | None = None,
         branch: str | None = None,
         timeout: int | None = None,
+        partial_match: bool = False,
         **kwargs: Any,
     ) -> int:
         """Return the number of nodes of a given kind."""
-        filters = kwargs
-        schema = self.schema.get(kind=kind, branch=branch)
+        filters: dict[str, Any] = dict(kwargs)
+
+        if partial_match:
+            filters["partial_match"] = True
 
+        schema = self.schema.get(kind=kind, branch=branch)
         branch = branch or self.default_branch
         if at:
             at = Timestamp(at)
 
+        data: dict[str, Any] = {
+            "count": None,
+            "@filters": filters,
+        }
+
         response = self.execute_graphql(
-            query=Query(query={schema.kind: {"count": None, "@filters": filters}}).render(),
+            query=Query(query={schema.kind: data}).render(),
             branch_name=branch,
             at=at,
             timeout=timeout,
@@ -1957,7 +1990,7 @@ class InfrahubClientSync(BaseClient):
             related_nodes = []
             batch_process = self.create_batch()
 
-            count = self.count(kind=schema.kind, **filters)
+            count = self.count(kind=schema.kind, partial_match=partial_match, **filters)
             total_pages = (count + pagination_size - 1) // pagination_size
 
             for page_number in range(1, total_pages + 1):

infrahub_sdk/node/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from .constants import (
+    ARTIFACT_DEFINITION_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE,
+    ARTIFACT_FETCH_FEATURE_NOT_SUPPORTED_MESSAGE,
+    ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE,
+    HFID_STR_SEPARATOR,
+    IP_TYPES,
+    PROPERTIES_FLAG,
+    PROPERTIES_OBJECT,
+    SAFE_VALUE,
+)
+from .node import InfrahubNode, InfrahubNodeBase, InfrahubNodeSync
+from .parsers import parse_human_friendly_id
+from .property import NodeProperty
+from .related_node import RelatedNode, RelatedNodeBase, RelatedNodeSync
+from .relationship import RelationshipManager, RelationshipManagerBase, RelationshipManagerSync
+
+__all__ = [
+    "ARTIFACT_DEFINITION_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE",
+    "ARTIFACT_FETCH_FEATURE_NOT_SUPPORTED_MESSAGE",
+    "ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE",
+    "HFID_STR_SEPARATOR",
+    "IP_TYPES",
+    "PROPERTIES_FLAG",
+    "PROPERTIES_OBJECT",
+    "SAFE_VALUE",
+    "InfrahubNode",
+    "InfrahubNodeBase",
+    "InfrahubNodeSync",
+    "NodeProperty",
+    "RelatedNode",
+    "RelatedNodeBase",
+    "RelatedNodeSync",
+    "RelationshipManager",
+    "RelationshipManagerBase",
+    "RelationshipManagerSync",
+    "parse_human_friendly_id",
+]

infrahub_sdk/node/attribute.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import ipaddress
+from typing import TYPE_CHECKING, Any, Callable, get_args
+
+from ..protocols_base import CoreNodeBase
+from ..uuidt import UUIDT
+from .constants import IP_TYPES, PROPERTIES_FLAG, PROPERTIES_OBJECT, SAFE_VALUE
+from .property import NodeProperty
+
+if TYPE_CHECKING:
+    from ..schema import AttributeSchemaAPI
+
+
+class Attribute:
+    """Represents an attribute of a Node, including its schema, value, and properties."""
+
+    def __init__(self, name: str, schema: AttributeSchemaAPI, data: Any | dict):
+        """
+        Args:
+            name (str): The name of the attribute.
+            schema (AttributeSchema): The schema defining the attribute.
+            data (Union[Any, dict]): The data for the attribute, either in raw form or as a dictionary.
+        """
+        self.name = name
+        self._schema = schema
+
+        if not isinstance(data, dict) or "value" not in data.keys():
+            data = {"value": data}
+
+        self._properties_flag = PROPERTIES_FLAG
+        self._properties_object = PROPERTIES_OBJECT
+        self._properties = self._properties_flag + self._properties_object
+
+        self._read_only = ["updated_at", "is_inherited"]
+
+        self.id: str | None = data.get("id", None)
+
+        self._value: Any | None = data.get("value", None)
+        self.value_has_been_mutated = False
+        self.is_default: bool | None = data.get("is_default", None)
+        self.is_from_profile: bool | None = data.get("is_from_profile", None)
+
+        if self._value:
+            value_mapper: dict[str, Callable] = {
+                "IPHost": ipaddress.ip_interface,
+                "IPNetwork": ipaddress.ip_network,
+            }
+            mapper = value_mapper.get(schema.kind, lambda value: value)
+            self._value = mapper(data.get("value"))
+
+        self.is_inherited: bool | None = data.get("is_inherited", None)
+        self.updated_at: str | None = data.get("updated_at", None)
+
+        self.is_visible: bool | None = data.get("is_visible", None)
+        self.is_protected: bool | None = data.get("is_protected", None)
+
+        self.source: NodeProperty | None = None
+        self.owner: NodeProperty | None = None
+
+        for prop_name in self._properties_object:
+            if data.get(prop_name):
+                setattr(self, prop_name, NodeProperty(data=data.get(prop_name)))  # type: ignore[arg-type]
+
+    @property
+    def value(self) -> Any:
+        return self._value
+
+    @value.setter
+    def value(self, value: Any) -> None:
+        self._value = value
+        self.value_has_been_mutated = True
+
+    def _generate_input_data(self) -> dict | None:
+        data: dict[str, Any] = {}
+        variables: dict[str, Any] = {}
+
+        if self.value is None:
+            return data
+
+        if isinstance(self.value, str):
+            if SAFE_VALUE.match(self.value):
+                data["value"] = self.value
+            else:
+                var_name = f"value_{UUIDT.new().hex}"
+                variables[var_name] = self.value
+                data["value"] = f"${var_name}"
+        elif isinstance(self.value, get_args(IP_TYPES)):
+            data["value"] = self.value.with_prefixlen
+        elif isinstance(self.value, CoreNodeBase) and self.value.is_resource_pool():
+            data["from_pool"] = {"id": self.value.id}
+        else:
+            data["value"] = self.value
+
+        for prop_name in self._properties_flag:
+            if getattr(self, prop_name) is not None:
+                data[prop_name] = getattr(self, prop_name)
+
+        for prop_name in self._properties_object:
+            if getattr(self, prop_name) is not None:
+                data[prop_name] = getattr(self, prop_name)._generate_input_data()
+
+        return {"data": data, "variables": variables}
+
+    def _generate_query_data(self, property: bool = False) -> dict | None:
+        data: dict[str, Any] = {"value": None}
+
+        if property:
+            data.update({"is_default": None, "is_from_profile": None})
+
+            for prop_name in self._properties_flag:
+                data[prop_name] = None
+            for prop_name in self._properties_object:
+                data[prop_name] = {"id": None, "display_label": None, "__typename": None}
+
+        return data
+
+    def _generate_mutation_query(self) -> dict[str, Any]:
+        if isinstance(self.value, CoreNodeBase) and self.value.is_resource_pool():
+            # If it points to a pool, ask for the value of the pool allocated resource
+            return {self.name: {"value": None}}
+        return {}

infrahub_sdk/node/constants.py

@@ -0,0 +1,21 @@
+import ipaddress
+import re
+from typing import Union
+
+PROPERTIES_FLAG = ["is_visible", "is_protected"]
+PROPERTIES_OBJECT = ["source", "owner"]
+SAFE_VALUE = re.compile(r"(^[\. /:a-zA-Z0-9_-]+$)|(^$)")
+
+IP_TYPES = Union[ipaddress.IPv4Interface, ipaddress.IPv6Interface, ipaddress.IPv4Network, ipaddress.IPv6Network]
+
+ARTIFACT_FETCH_FEATURE_NOT_SUPPORTED_MESSAGE = (
+    "calling artifact_fetch is only supported for nodes that are Artifact Definition target"
+)
+ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE = (
+    "calling artifact_generate is only supported for nodes that are Artifact Definition targets"
+)
+ARTIFACT_DEFINITION_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE = (
+    "calling generate is only supported for CoreArtifactDefinition nodes"
+)
+
+HFID_STR_SEPARATOR = "__"