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

infrahub_sdk/node/related_node.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 class RelatedNodeBase:
     """Base class for representing a related node in a relationship."""
 
-    def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict, name: str | None = None):
+    def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict, name: str | None = None) -> None:
         """
         Args:
             branch (str): The branch where the related node resides.
@@ -189,7 +189,7 @@ class RelatedNode(RelatedNodeBase):
         schema: RelationshipSchemaAPI,
         data: Any | dict,
         name: str | None = None,
-    ):
+    ) -> None:
         """
         Args:
             client (InfrahubClient): The client used to interact with the backend asynchronously.
@@ -236,7 +236,7 @@ class RelatedNodeSync(RelatedNodeBase):
         schema: RelationshipSchemaAPI,
         data: Any | dict,
         name: str | None = None,
-    ):
+    ) -> None:
         """
         Args:
             client (InfrahubClientSync): The client used to interact with the backend synchronously.

infrahub_sdk/node/relationship.py

@@ -4,7 +4,6 @@ from collections import defaultdict
 from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
-from ..batch import InfrahubBatch
 from ..exceptions import (
     Error,
     UninitializedError,
@@ -22,7 +21,7 @@ if TYPE_CHECKING:
 class RelationshipManagerBase:
     """Base class for RelationshipManager and RelationshipManagerSync"""
 
-    def __init__(self, name: str, branch: str, schema: RelationshipSchemaAPI):
+    def __init__(self, name: str, branch: str, schema: RelationshipSchemaAPI) -> None:
         """
         Args:
             name (str): The name of the relationship.
@@ -108,7 +107,7 @@ class RelationshipManager(RelationshipManagerBase):
         branch: str,
         schema: RelationshipSchemaAPI,
         data: Any | dict,
-    ):
+    ) -> None:
         """
         Args:
             name (str): The name of the relationship.
@@ -166,7 +165,7 @@ class RelationshipManager(RelationshipManagerBase):
                 raise Error("Unable to fetch the peer, id and/or typename are not defined")
             ids_per_kind_map[peer.typename].append(peer.id)
 
-        batch = InfrahubBatch(max_concurrent_execution=self.client.max_concurrent_execution)
+        batch = await self.client.create_batch()
         for kind, ids in ids_per_kind_map.items():
             batch.add(
                 task=self.client.filters,
@@ -231,7 +230,7 @@ class RelationshipManagerSync(RelationshipManagerBase):
         branch: str,
         schema: RelationshipSchemaAPI,
         data: Any | dict,
-    ):
+    ) -> None:
         """
         Args:
             name (str): The name of the relationship.
@@ -289,7 +288,6 @@ class RelationshipManagerSync(RelationshipManagerBase):
                 raise Error("Unable to fetch the peer, id and/or typename are not defined")
             ids_per_kind_map[peer.typename].append(peer.id)
 
-        # Unlike Async, no need to create a new batch from scratch because we are not using a semaphore
         batch = self.client.create_batch()
         for kind, ids in ids_per_kind_map.items():
             batch.add(

infrahub_sdk/object_store.py

@@ -16,7 +16,7 @@ class ObjectStoreBase:
 
 
 class ObjectStore(ObjectStoreBase):
-    def __init__(self, client: InfrahubClient):
+    def __init__(self, client: InfrahubClient) -> None:
         self.client = client
 
     async def get(self, identifier: str, tracker: str | None = None) -> str:
@@ -64,7 +64,7 @@ class ObjectStore(ObjectStoreBase):
 
 
 class ObjectStoreSync(ObjectStoreBase):
-    def __init__(self, client: InfrahubClientSync):
+    def __init__(self, client: InfrahubClientSync) -> None:
         self.client = client
 
     def get(self, identifier: str, tracker: str | None = None) -> str:

infrahub_sdk/operation.py

@@ -19,7 +19,7 @@ class InfrahubOperation:
         convert_query_response: bool,
         branch: str,
         root_directory: str,
-    ):
+    ) -> None:
         self.branch = branch
         self.convert_query_response = convert_query_response
         self.root_directory = root_directory or os.getcwd()

infrahub_sdk/protocols_generator/generator.py

@@ -34,7 +34,7 @@ def move_to_end_of_list(lst: list, item: str) -> list:
 
 
 class CodeGenerator:
-    def __init__(self, schema: dict[str, MainSchemaTypesAll]):
+    def __init__(self, schema: dict[str, MainSchemaTypesAll]) -> None:
         self.generics: dict[str, GenericSchemaAPI | GenericSchema] = {}
         self.nodes: dict[str, NodeSchemaAPI | NodeSchema] = {}
         self.profiles: dict[str, ProfileSchemaAPI] = {}

infrahub_sdk/pytest_plugin/exceptions.py

@@ -7,37 +7,37 @@ class Error(Exception):
 
 
 class InvalidResourceConfigError(Error):
-    def __init__(self, resource_name: str):
+    def __init__(self, resource_name: str) -> None:
         super().__init__(f"Improperly configured resource with name '{resource_name}'.")
 
 
 class DirectoryNotFoundError(Error):
-    def __init__(self, name: str, message: str = ""):
+    def __init__(self, name: str, message: str = "") -> None:
         self.message = message or f"Unable to find directory {name!r}."
         super().__init__(self.message)
 
 
 class FileNotValidError(Error):
-    def __init__(self, name: str, message: str = ""):
+    def __init__(self, name: str, message: str = "") -> None:
         self.message = message or f"Unable to access file {name!r}."
         super().__init__(self.message)
 
 
 class OutputMatchError(Error):
-    def __init__(self, name: str, message: str = "", differences: str = ""):
+    def __init__(self, name: str, message: str = "", differences: str = "") -> None:
         self.message = message or f"Rendered output does not match expected output for {name!r}."
         self.differences = differences
         super().__init__(self.message)
 
 
 class Jinja2TransformError(Error):
-    def __init__(self, name: str, message: str = ""):
+    def __init__(self, name: str, message: str = "") -> None:
         self.message = message or f"Unexpected error happened while processing {name!r}."
         super().__init__(self.message)
 
 
 class Jinja2TransformUndefinedError(Error):
-    def __init__(self, name: str, rtb: Traceback, errors: list[tuple[Frame, Syntax]], message: str = ""):
+    def __init__(self, name: str, rtb: Traceback, errors: list[tuple[Frame, Syntax]], message: str = "") -> None:
         self.rtb = rtb
         self.errors = errors
         self.message = message or f"Unable to render Jinja2 transform {name!r}."
@@ -45,18 +45,18 @@ class Jinja2TransformUndefinedError(Error):
 
 
 class CheckDefinitionError(Error):
-    def __init__(self, name: str, message: str = ""):
+    def __init__(self, name: str, message: str = "") -> None:
         self.message = message or f"Check {name!r} is not properly defined."
         super().__init__(self.message)
 
 
 class CheckResultError(Error):
-    def __init__(self, name: str, message: str = ""):
+    def __init__(self, name: str, message: str = "") -> None:
         self.message = message or f"Unexpected result for check {name!r}."
         super().__init__(self.message)
 
 
 class PythonTransformDefinitionError(Error):
-    def __init__(self, name: str, message: str = ""):
+    def __init__(self, name: str, message: str = "") -> None:
         self.message = message or f"Python transform {name!r} is not properly defined."
         super().__init__(self.message)

infrahub_sdk/pytest_plugin/items/base.py

@@ -25,7 +25,7 @@ class InfrahubItem(pytest.Item):
         resource_config: InfrahubRepositoryConfigElement,
         test: InfrahubTest,
         **kwargs: dict[str, Any],
-    ):
+    ) -> None:
         super().__init__(*args, **kwargs)  # type: ignore[arg-type]
         self.resource_name: str = resource_name
         self.resource_config: InfrahubRepositoryConfigElement = resource_config

infrahub_sdk/pytest_plugin/items/check.py

@@ -27,7 +27,7 @@ class InfrahubCheckItem(InfrahubItem):
         resource_config: InfrahubRepositoryConfigElement,
         test: InfrahubTest,
         **kwargs: dict[str, Any],
-    ):
+    ) -> None:
         super().__init__(*args, resource_name=resource_name, resource_config=resource_config, test=test, **kwargs)
 
         self.check_instance: InfrahubCheck

infrahub_sdk/pytest_plugin/items/python_transform.py

@@ -28,7 +28,7 @@ class InfrahubPythonTransformItem(InfrahubItem):
         resource_config: InfrahubRepositoryConfigElement,
         test: InfrahubTest,
         **kwargs: dict[str, Any],
-    ):
+    ) -> None:
         super().__init__(*args, resource_name=resource_name, resource_config=resource_config, test=test, **kwargs)
 
         self.transform_instance: InfrahubTransform

infrahub_sdk/repository.py

@@ -7,7 +7,7 @@ from dulwich.repo import Repo
 
 
 class GitRepoManager:
-    def __init__(self, root_directory: str, branch: str = "main"):
+    def __init__(self, root_directory: str, branch: str = "main") -> None:
         self.root_directory = root_directory
         self.branch = branch
         self.git: Repo = self.initialize_repo()

infrahub_sdk/schema/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 import json
 import warnings
 from collections.abc import MutableMapping
@@ -90,11 +91,31 @@ MainSchemaTypesAll: TypeAlias = Union[
 ]
 
 
+class SchemaWarningType(Enum):
+    DEPRECATION = "deprecation"
+
+
+class SchemaWarningKind(BaseModel):
+    kind: str = Field(..., description="The kind impacted by the warning")
+    field: str | None = Field(default=None, description="The attribute or relationship impacted by the warning")
+
+    @property
+    def display(self) -> str:
+        suffix = f".{self.field}" if self.field else ""
+        return f"{self.kind}{suffix}"
+
+
+class SchemaWarning(BaseModel):
+    type: SchemaWarningType = Field(..., description="The type of warning")
+    kinds: list[SchemaWarningKind] = Field(default_factory=list, description="The kinds impacted by the warning")
+    message: str = Field(..., description="The message that describes the warning")
+
+
 class InfrahubSchemaBase:
     client: InfrahubClient | InfrahubClientSync
     cache: dict[str, BranchSchema]
 
-    def __init__(self, client: InfrahubClient | InfrahubClientSync):
+    def __init__(self, client: InfrahubClient | InfrahubClientSync) -> None:
         self.client = client
         self.cache = {}
 
@@ -169,7 +190,9 @@ class InfrahubSchemaBase:
     def _validate_load_schema_response(response: httpx.Response) -> SchemaLoadResponse:
         if response.status_code == httpx.codes.OK:
             status = response.json()
-            return SchemaLoadResponse(hash=status["hash"], previous_hash=status["previous_hash"])
+            return SchemaLoadResponse(
+                hash=status["hash"], previous_hash=status["previous_hash"], warnings=status.get("warnings") or []
+            )
 
         if response.status_code in [
             httpx.codes.BAD_REQUEST,
@@ -185,12 +208,16 @@ class InfrahubSchemaBase:
 
     @staticmethod
     def _get_schema_name(schema: type[SchemaType | SchemaTypeSync] | str) -> str:
-        if hasattr(schema, "_is_runtime_protocol") and schema._is_runtime_protocol:  # type: ignore[union-attr]
-            return schema.__name__  # type: ignore[union-attr]
-
         if isinstance(schema, str):
             return schema
 
+        if hasattr(schema, "_is_runtime_protocol") and getattr(schema, "_is_runtime_protocol", None):
+            if inspect.iscoroutinefunction(schema.save):
+                return schema.__name__
+            if schema.__name__[-4:] == "Sync":
+                return schema.__name__[:-4]
+            return schema.__name__
+
         raise ValueError("schema must be a protocol or a string")
 
     @staticmethod
@@ -802,6 +829,7 @@ class SchemaLoadResponse(BaseModel):
     hash: str = Field(default="", description="The new hash for the entire schema")
     previous_hash: str = Field(default="", description="The previous hash for the entire schema")
     errors: dict = Field(default_factory=dict, description="Errors reported by the server")
+    warnings: list[SchemaWarning] = Field(default_factory=list, description="Warnings reported by the server")
 
     @property
     def schema_updated(self) -> bool:

infrahub_sdk/spec/models.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class InfrahubObjectParameters(BaseModel):
+    expand_range: bool = False

infrahub_sdk/spec/object.py

@@ -1,17 +1,15 @@
 from __future__ import annotations
 
-import copy
-import re
-from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, Field
 
 from ..exceptions import ObjectValidationError, ValidationError
 from ..schema import GenericSchemaAPI, RelationshipKind, RelationshipSchema
 from ..yaml import InfrahubFile, InfrahubFileKind
-from .range_expansion import MATCH_PATTERN, range_expansion
+from .models import InfrahubObjectParameters
+from .processors.factory import DataProcessorFactory
 
 if TYPE_CHECKING:
     from ..client import InfrahubClient
@@ -46,11 +44,6 @@ class RelationshipDataFormat(str, Enum):
     MANY_REF = "many_ref_list"
 
 
-class ObjectStrategy(str, Enum):
-    NORMAL = "normal"
-    RANGE_EXPAND = "range_expand"
-
-
 class RelationshipInfo(BaseModel):
     name: str
     rel_schema: RelationshipSchema
@@ -173,97 +166,21 @@ async def get_relationship_info(
     return info
 
 
-def expand_data_with_ranges(data: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Expand any item in data with range pattern in any value. Supports multiple fields, requires equal expansion length."""
-    range_pattern = re.compile(MATCH_PATTERN)
-    expanded = []
-    for item in data:
-        # Find all fields to expand
-        expand_fields = {}
-        for key, value in item.items():
-            if isinstance(value, str) and range_pattern.search(value):
-                try:
-                    expand_fields[key] = range_expansion(value)
-                except Exception:
-                    # If expansion fails, treat as no expansion
-                    expand_fields[key] = [value]
-        if not expand_fields:
-            expanded.append(item)
-            continue
-        # Check all expanded lists have the same length
-        lengths = [len(v) for v in expand_fields.values()]
-        if len(set(lengths)) > 1:
-            raise ValidationError(f"Range expansion mismatch: fields expanded to different lengths: {lengths}")
-        n = lengths[0]
-        # Zip expanded values and produce new items
-        for i in range(n):
-            new_item = copy.deepcopy(item)
-            for key, values in expand_fields.items():
-                new_item[key] = values[i]
-            expanded.append(new_item)
-    return expanded
-
-
-class DataProcessor(ABC):
-    """Abstract base class for data processing strategies"""
-
-    @abstractmethod
-    def process_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        """Process the data according to the strategy"""
-
-
-class SingleDataProcessor(DataProcessor):
-    """Process data without any expansion"""
-
-    def process_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        return data
-
-
-class RangeExpandDataProcessor(DataProcessor):
-    """Process data with range expansion"""
-
-    def process_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        return expand_data_with_ranges(data)
-
-
-class DataProcessorFactory:
-    """Factory to create appropriate data processor based on strategy"""
-
-    _processors: ClassVar[dict[ObjectStrategy, type[DataProcessor]]] = {
-        ObjectStrategy.NORMAL: SingleDataProcessor,
-        ObjectStrategy.RANGE_EXPAND: RangeExpandDataProcessor,
-    }
-
-    @classmethod
-    def get_processor(cls, strategy: ObjectStrategy) -> DataProcessor:
-        processor_class = cls._processors.get(strategy)
-        if not processor_class:
-            raise ValueError(
-                f"Unknown strategy: {strategy} - no processor found. Valid strategies are: {list(cls._processors.keys())}"
-            )
-        return processor_class()
-
-    @classmethod
-    def register_processor(cls, strategy: ObjectStrategy, processor_class: type[DataProcessor]) -> None:
-        """Register a new processor for a strategy - useful for future extensions"""
-        cls._processors[strategy] = processor_class
-
-
 class InfrahubObjectFileData(BaseModel):
     kind: str
-    strategy: ObjectStrategy = ObjectStrategy.NORMAL
+    parameters: InfrahubObjectParameters = Field(default_factory=InfrahubObjectParameters)
     data: list[dict[str, Any]] = Field(default_factory=list)
 
-    def _get_processed_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    async def _get_processed_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """Get data processed according to the strategy"""
-        processor = DataProcessorFactory.get_processor(self.strategy)
-        return processor.process_data(data)
+
+        return await DataProcessorFactory.process_data(kind=self.kind, parameters=self.parameters, data=data)
 
     async def validate_format(self, client: InfrahubClient, branch: str | None = None) -> list[ObjectValidationError]:
         errors: list[ObjectValidationError] = []
         schema = await client.schema.get(kind=self.kind, branch=branch)
 
-        processed_data = self._get_processed_data(data=self.data)
+        processed_data = await self._get_processed_data(data=self.data)
         self.data = processed_data
 
         for idx, item in enumerate(processed_data):
@@ -275,14 +192,14 @@ class InfrahubObjectFileData(BaseModel):
                     data=item,
                     branch=branch,
                     default_schema_kind=self.kind,
-                    strategy=self.strategy,  # Pass strategy down
+                    parameters=self.parameters,
                 )
             )
         return errors
 
     async def process(self, client: InfrahubClient, branch: str | None = None) -> None:
         schema = await client.schema.get(kind=self.kind, branch=branch)
-        processed_data = self._get_processed_data(data=self.data)
+        processed_data = await self._get_processed_data(data=self.data)
 
         for idx, item in enumerate(processed_data):
             await self.create_node(
@@ -292,6 +209,7 @@ class InfrahubObjectFileData(BaseModel):
                 position=[idx + 1],
                 branch=branch,
                 default_schema_kind=self.kind,
+                parameters=self.parameters,
             )
 
     @classmethod
@@ -304,8 +222,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
-        strategy: ObjectStrategy = ObjectStrategy.NORMAL,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[ObjectValidationError]:
+        parameters = parameters or InfrahubObjectParameters()
         errors: list[ObjectValidationError] = []
         context = context.copy() if context else {}
 
@@ -354,7 +273,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
-                        strategy=strategy,
+                        parameters=parameters,
                     )
                 )
 
@@ -370,8 +289,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
-        strategy: ObjectStrategy = ObjectStrategy.NORMAL,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[ObjectValidationError]:
+        parameters = parameters or InfrahubObjectParameters()
         context = context.copy() if context else {}
         errors: list[ObjectValidationError] = []
 
@@ -399,6 +319,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
             )
             return errors
@@ -412,11 +333,11 @@ class InfrahubObjectFileData(BaseModel):
             rel_info.find_matching_relationship(peer_schema=peer_schema)
             context.update(rel_info.get_context(value="placeholder"))
 
-            # Use strategy-aware data processing
-            processor = DataProcessorFactory.get_processor(strategy)
-            expanded_data = processor.process_data(data["data"])
+            processed_data = await DataProcessorFactory.process_data(
+                kind=peer_kind, data=data["data"], parameters=parameters
+            )
 
-            for idx, peer_data in enumerate(expanded_data):
+            for idx, peer_data in enumerate(processed_data):
                 context["list_index"] = idx
                 errors.extend(
                     await cls.validate_object(
@@ -427,7 +348,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
-                        strategy=strategy,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -452,6 +373,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -478,7 +400,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> InfrahubNode:
+        parameters = parameters or InfrahubObjectParameters()
         context = context.copy() if context else {}
 
         errors = await cls.validate_object(
@@ -489,6 +413,7 @@ class InfrahubObjectFileData(BaseModel):
             context=context,
             branch=branch,
             default_schema_kind=default_schema_kind,
+            parameters=parameters,
         )
         if errors:
             messages = [str(error) for error in errors]
@@ -545,6 +470,9 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=InfrahubObjectParameters(**value.get("parameters"))
+                            if "parameters" in value
+                            else None,
                         )
                         clean_data[key] = nodes
 
@@ -583,6 +511,9 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=InfrahubObjectParameters(**data[rel].get("parameters"))
+                if "parameters" in data[rel]
+                else None,
             )
 
         return node
@@ -598,7 +529,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[InfrahubNode]:
+        parameters = parameters or InfrahubObjectParameters()
         nodes: list[InfrahubNode] = []
         context = context.copy() if context else {}
 
@@ -618,6 +551,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
             return [new_node]
 
@@ -631,7 +565,10 @@ class InfrahubObjectFileData(BaseModel):
                 rel_info.find_matching_relationship(peer_schema=peer_schema)
                 context.update(rel_info.get_context(value=parent_node.id))
 
-            expanded_data = expand_data_with_ranges(data=data["data"])
+            expanded_data = await DataProcessorFactory.process_data(
+                kind=peer_kind, data=data["data"], parameters=parameters
+            )
+
             for idx, peer_data in enumerate(expanded_data):
                 context["list_index"] = idx
                 if isinstance(peer_data, dict):
@@ -643,6 +580,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                     nodes.append(node)
             return nodes
@@ -668,6 +606,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
                 nodes.append(node)
 

infrahub_sdk/spec/processors/data_processor.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class DataProcessor(ABC):
+    """Abstract base class for data processing strategies"""
+
+    @abstractmethod
+    async def process_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Process the data according to the strategy"""

infrahub_sdk/spec/processors/factory.py

@@ -0,0 +1,34 @@
+from collections.abc import Sequence
+from typing import Any
+
+from ..models import InfrahubObjectParameters
+from .data_processor import DataProcessor
+from .range_expand_processor import RangeExpandDataProcessor
+
+PROCESSOR_PER_KIND: dict[str, DataProcessor] = {}
+
+
+class DataProcessorFactory:
+    """Factory to create appropriate data processor based on strategy"""
+
+    @classmethod
+    def get_processors(cls, kind: str, parameters: InfrahubObjectParameters) -> Sequence[DataProcessor]:
+        processors: list[DataProcessor] = []
+        if parameters.expand_range:
+            processors.append(RangeExpandDataProcessor())
+        if kind in PROCESSOR_PER_KIND:
+            processors.append(PROCESSOR_PER_KIND[kind])
+
+        return processors
+
+    @classmethod
+    async def process_data(
+        cls,
+        kind: str,
+        data: list[dict[str, Any]],
+        parameters: InfrahubObjectParameters,
+    ) -> list[dict[str, Any]]:
+        processors = cls.get_processors(kind=kind, parameters=parameters)
+        for processor in processors:
+            data = await processor.process_data(data=data)
+        return data