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

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/pools/registration.py

@@ -0,0 +1,22 @@
+from infrahub.core.registry import registry
+from infrahub.exceptions import SchemaNotFoundError
+
+
+def get_branches_with_schema_number_pool(kind: str, attribute_name: str) -> list[str]:
+    """Return branches where schema defined NumberPool exists"""
+
+    registered_branches = []
+    active_branches = registry.schema.get_branches()
+
+    for active_branch in active_branches:
+        try:
+            schema = registry.schema.get(name=kind, branch=active_branch)
+        except SchemaNotFoundError:
+            continue
+
+        if attribute_name in schema.attribute_names:
+            attribute = schema.get_attribute(name=attribute_name)
+            if attribute.kind == "NumberPool":
+                registered_branches.append(active_branch)
+
+    return registered_branches

infrahub/pools/tasks.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.constants import NumberPoolType
+from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreNumberPool
+from infrahub.core.registry import registry
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.pools.registration import get_branches_with_schema_number_pool
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+
+
+@flow(
+    name="validate-schema-number-pools",
+    flow_run_name="Validate schema number pools on {branch_name}",
+)
+async def validate_schema_number_pools(
+    branch_name: str,  # noqa: ARG001
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+
+    async with service.database.start_session() as dbs:
+        schema_number_pools = await NodeManager.query(
+            db=dbs, schema=CoreNumberPool, filters={"pool_type__value": NumberPoolType.SCHEMA.value}
+        )
+
+    for schema_number_pool in list(schema_number_pools):
+        defined_on_branches = get_branches_with_schema_number_pool(
+            kind=schema_number_pool.node.value, attribute_name=schema_number_pool.node_attribute.value
+        )
+        if registry.default_branch in defined_on_branches:
+            schema = registry.schema.get(name=schema_number_pool.node.value, branch=registry.default_branch)
+            attribute = schema.get_attribute(name=schema_number_pool.node_attribute.value)
+            number_pool_updated = False
+            if isinstance(attribute.parameters, NumberPoolParameters):
+                if schema_number_pool.start_range.value != attribute.parameters.start_range:
+                    schema_number_pool.start_range.value = attribute.parameters.start_range
+                    number_pool_updated = True
+                if schema_number_pool.end_range.value != attribute.parameters.end_range:
+                    schema_number_pool.end_range.value = attribute.parameters.end_range
+                    number_pool_updated = True
+
+            if number_pool_updated:
+                log.info(
+                    f"Updating NumberPool={schema_number_pool.id} based on changes in the schema on {registry.default_branch}"
+                )
+                await schema_number_pool.save(db=service.database)
+
+        elif not defined_on_branches:
+            log.info(f"Deleting number pool (id={schema_number_pool.id}) as it is no longer defined in the schema")
+            await schema_number_pool.delete(db=service.database)

infrahub/schema/tasks.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.pools.tasks import validate_schema_number_pools
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workflows.utils import wait_for_schema_to_converge
+
+
+@flow(
+    name="schema-updated",
+    flow_run_name="Running actions after the schema was updated on '{branch_name}'",
+)
+async def schema_updated(
+    branch_name: str,
+    schema_hash: str,  # noqa: ARG001
+    context: InfrahubContext,
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+    await wait_for_schema_to_converge(
+        branch_name=branch_name, component=service.component, db=service.database, log=log
+    )
+
+    await validate_schema_number_pools(branch_name=branch_name, context=context, service=service)

infrahub/schema/triggers.py

@@ -0,0 +1,23 @@
+from infrahub.events.schema_action import SchemaUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import SCHEMA_UPDATED
+
+TRIGGER_SCHEMA_UPDATED = BuiltinTriggerDefinition(
+    name="schema-updated-trigger",
+    trigger=EventTrigger(
+        events={SchemaUpdatedEvent.event_name},
+    ),
+    actions=[
+        ExecuteWorkflow(
+            workflow=SCHEMA_UPDATED,
+            parameters={
+                "branch_name": "{{ event.payload['data']['branch_name'] }}",
+                "schema_hash": "{{ event.payload['data']['schema_hash'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

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/trigger/catalogue.py

@@ -1,15 +1,19 @@
 from infrahub.actions.triggers import TRIGGER_ACTION_RULE_UPDATE
+from infrahub.branch.triggers import TRIGGER_BRANCH_MERGED
 from infrahub.computed_attribute.triggers import (
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
 )
+from infrahub.schema.triggers import TRIGGER_SCHEMA_UPDATED
 from infrahub.trigger.models import TriggerDefinition
 from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
 
 builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_ACTION_RULE_UPDATE,
+    TRIGGER_BRANCH_MERGED,
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_SCHEMA_UPDATED,
     TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,
 ]

infrahub/trigger/models.py

@@ -5,10 +5,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from prefect.events.actions import RunDeployment
-from prefect.events.schemas.automations import (
-    Automation,  # noqa: TC002
-    Posture,
-)
+from prefect.events.schemas.automations import Automation, Posture
 from prefect.events.schemas.automations import EventTrigger as PrefectEventTrigger
 from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
@@ -28,6 +25,10 @@ class TriggerSetupReport(BaseModel):
     deleted: list[Automation] = Field(default_factory=list)
     unchanged: list[TriggerDefinition] = Field(default_factory=list)
 
+    @property
+    def in_use_count(self) -> int:
+        return len(self.created + self.updated + self.unchanged)
+
 
 class TriggerType(str, Enum):
     ACTION_TRIGGER_RULE = "action_trigger_rule"

infrahub/trigger/setup.py

@@ -1,12 +1,14 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Awaitable, Callable
 
 from prefect import get_run_logger, task
 from prefect.automations import AutomationCore
 from prefect.cache_policies import NONE
-from prefect.client.orchestration import PrefectClient
+from prefect.client.orchestration import PrefectClient, get_client
 from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
 from prefect.events.schemas.automations import Automation
 
+from infrahub import lock
+from infrahub.database import InfrahubDatabase
 from infrahub.trigger.models import TriggerDefinition
 
 from .models import TriggerSetupReport, TriggerType
@@ -27,6 +29,28 @@ def compare_automations(target: AutomationCore, existing: Automation) -> bool:
     return target_dump == existing_dump
 
 
+@task(name="trigger-setup-specific", task_run_name="Setup triggers of a specific kind", cache_policy=NONE)  # type: ignore[arg-type]
+async def setup_triggers_specific(
+    gatherer: Callable[[InfrahubDatabase | None], Awaitable[list[TriggerDefinition]]],
+    trigger_type: TriggerType,
+    db: InfrahubDatabase | None = None,
+) -> TriggerSetupReport:
+    async with lock.registry.get(
+        name=f"configure-action-rules-{trigger_type.value}", namespace="trigger-rules", local=False
+    ):
+        if db:
+            async with db.start_session(read_only=True) as dbs:
+                triggers = await gatherer(dbs)
+        else:
+            triggers = await gatherer(db)
+        async with get_client(sync_client=False) as prefect_client:
+            return await setup_triggers(
+                client=prefect_client,
+                triggers=triggers,
+                trigger_type=trigger_type,
+            )  # type: ignore[misc]
+
+
 @task(name="trigger-setup", task_run_name="Setup triggers", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_triggers(
     client: PrefectClient,

infrahub/trigger/tasks.py

@@ -6,7 +6,7 @@ from infrahub.computed_attribute.gather import (
     gather_trigger_computed_attribute_jinja2,
     gather_trigger_computed_attribute_python,
 )
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.services import InfrahubServices
 from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.webhook.gather import gather_trigger_webhook
 

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/webhook/tasks.py

@@ -14,7 +14,7 @@ from prefect.logging import get_run_logger
 from infrahub.message_bus.types import KVTTL
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.trigger.models import TriggerType
-from infrahub.trigger.setup import setup_triggers
+from infrahub.trigger.setup import setup_triggers_specific
 from infrahub.workflows.utils import add_tags
 
 from .gather import gather_trigger_webhook
@@ -111,16 +111,13 @@ async def webhook_process(
 async def configure_webhook_all(service: InfrahubServices) -> None:
     log = get_run_logger()
 
-    triggers = await gather_trigger_webhook(db=service.database)
-
-    async with get_client(sync_client=False) as prefect_client:
-        await setup_triggers(
-            client=prefect_client,
-            triggers=triggers,
-            trigger_type=TriggerType.WEBHOOK,
-        )  # type: ignore[misc]
+    async with service.database.start_session(read_only=True) as db:
+        triggers = await gather_trigger_webhook(db=db)
 
     log.info(f"{len(triggers)} Webhooks automation configuration completed")
+    await setup_triggers_specific(
+        gatherer=gather_trigger_webhook, db=service.database, trigger_type=TriggerType.WEBHOOK
+    )  # type: ignore[misc]
 
 
 @flow(name="webhook-setup-automation-one", flow_run_name="Configurate webhook for {webhook_name}")

infrahub/workflows/catalogue.py

@@ -242,6 +242,14 @@ BRANCH_MERGE = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+BRANCH_MERGED = WorkflowDefinition(
+    name="branch-merged",
+    type=WorkflowType.CORE,
+    module="infrahub.branch.tasks",
+    function="branch_merged",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
 BRANCH_MERGE_POST_PROCESS = WorkflowDefinition(
     name="branch-merge-post-process",
     type=WorkflowType.CORE,
@@ -250,7 +258,6 @@ BRANCH_MERGE_POST_PROCESS = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
-
 BRANCH_MERGE_MUTATION = WorkflowDefinition(
     name="merge-branch-mutation",
     type=WorkflowType.CORE,
@@ -498,6 +505,14 @@ GIT_REPOSITORY_MERGE_CONFLICTS_CHECKS_RUN = WorkflowDefinition(
     function="run_check_merge_conflicts",
 )
 
+SCHEMA_UPDATED = WorkflowDefinition(
+    name="schema-updated",
+    type=WorkflowType.CORE,
+    module="infrahub.schema.tasks",
+    function="schema_updated",
+)
+
+
 TRIGGER_CONFIGURE_ALL = WorkflowDefinition(
     name="trigger-configure-all",
     type=WorkflowType.CORE,
@@ -506,6 +521,14 @@ TRIGGER_CONFIGURE_ALL = WorkflowDefinition(
 )
 
 
+VALIDATE_SCHEMA_NUMBER_POOLS = WorkflowDefinition(
+    name="validate-schema-number-pools",
+    type=WorkflowType.CORE,
+    module="infrahub.pools.tasks",
+    function="validate_schema_number_pools",
+)
+
+
 worker_pools = [INFRAHUB_WORKER_POOL]
 
 workflows = [
@@ -517,6 +540,7 @@ workflows = [
     BRANCH_CREATE,
     BRANCH_DELETE,
     BRANCH_MERGE,
+    BRANCH_MERGED,
     BRANCH_MERGE_MUTATION,
     BRANCH_MERGE_POST_PROCESS,
     BRANCH_REBASE,
@@ -564,6 +588,7 @@ workflows = [
     REQUEST_PROPOSED_CHANGE_USER_TESTS,
     RUN_GENERATOR_AS_CHECK,
     SCHEMA_APPLY_MIGRATION,
+    SCHEMA_UPDATED,
     SCHEMA_VALIDATE_MIGRATION,
     TRANSFORM_JINJA2_RENDER,
     TRANSFORM_PYTHON_RENDER,
@@ -572,6 +597,7 @@ workflows = [
     TRIGGER_GENERATOR_DEFINITION_RUN,
     TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
     TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+    VALIDATE_SCHEMA_NUMBER_POOLS,
     WEBHOOK_CONFIGURE_ALL,
     WEBHOOK_CONFIGURE_ONE,
     WEBHOOK_DELETE_AUTOMATION,

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",
+]