infrahub-server 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub_sdk/spec/object.py

@@ -8,6 +8,8 @@ from pydantic import BaseModel, Field
 from ..exceptions import ObjectValidationError, ValidationError
 from ..schema import GenericSchemaAPI, RelationshipKind, RelationshipSchema
 from ..yaml import InfrahubFile, InfrahubFileKind
+from .models import InfrahubObjectParameters
+from .processors.factory import DataProcessorFactory
 
 if TYPE_CHECKING:
     from ..client import InfrahubClient
@@ -166,12 +168,22 @@ async def get_relationship_info(
 
 class InfrahubObjectFileData(BaseModel):
     kind: str
+    parameters: InfrahubObjectParameters = Field(default_factory=InfrahubObjectParameters)
     data: list[dict[str, Any]] = Field(default_factory=list)
 
+    async def _get_processed_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Get data processed according to the strategy"""
+
+        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)
-        for idx, item in enumerate(self.data):
+
+        processed_data = await self._get_processed_data(data=self.data)
+        self.data = processed_data
+
+        for idx, item in enumerate(processed_data):
             errors.extend(
                 await self.validate_object(
                     client=client,
@@ -180,13 +192,16 @@ class InfrahubObjectFileData(BaseModel):
                     data=item,
                     branch=branch,
                     default_schema_kind=self.kind,
+                    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)
-        for idx, item in enumerate(self.data):
+        processed_data = await self._get_processed_data(data=self.data)
+
+        for idx, item in enumerate(processed_data):
             await self.create_node(
                 client=client,
                 schema=schema,
@@ -206,7 +221,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[ObjectValidationError]:
+        parameters = parameters or InfrahubObjectParameters()
         errors: list[ObjectValidationError] = []
         context = context.copy() if context else {}
 
@@ -255,6 +272,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
 
@@ -270,7 +288,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[ObjectValidationError]:
+        parameters = parameters or InfrahubObjectParameters()
         context = context.copy() if context else {}
         errors: list[ObjectValidationError] = []
 
@@ -298,6 +318,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
             )
             return errors
@@ -311,7 +332,11 @@ class InfrahubObjectFileData(BaseModel):
             rel_info.find_matching_relationship(peer_schema=peer_schema)
             context.update(rel_info.get_context(value="placeholder"))
 
-            for idx, peer_data in enumerate(data["data"]):
+            processed_data = await DataProcessorFactory.process_data(
+                kind=peer_kind, data=data["data"], parameters=parameters
+            )
+
+            for idx, peer_data in enumerate(processed_data):
                 context["list_index"] = idx
                 errors.extend(
                     await cls.validate_object(
@@ -322,6 +347,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -346,6 +372,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -372,7 +399,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(
@@ -383,6 +412,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]
@@ -428,6 +458,7 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=parameters,
                         )
                         clean_data[key] = nodes[0]
 
@@ -439,6 +470,7 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=parameters,
                         )
                         clean_data[key] = nodes
 
@@ -477,6 +509,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
 
         return node
@@ -492,7 +525,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 {}
 
@@ -512,6 +547,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
             return [new_node]
 
@@ -525,7 +561,11 @@ class InfrahubObjectFileData(BaseModel):
                 rel_info.find_matching_relationship(peer_schema=peer_schema)
                 context.update(rel_info.get_context(value=parent_node.id))
 
-            for idx, peer_data in enumerate(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):
                     node = await cls.create_node(
@@ -536,6 +576,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                     nodes.append(node)
             return nodes
@@ -561,6 +602,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
                 nodes.append(node)
 
@@ -594,14 +636,20 @@ class ObjectFile(InfrahubFile):
     @property
     def spec(self) -> InfrahubObjectFileData:
         if not self._spec:
-            self._spec = InfrahubObjectFileData(**self.data.spec)
+            try:
+                self._spec = InfrahubObjectFileData(**self.data.spec)
+            except Exception as exc:
+                raise ValidationError(identifier=str(self.location), message=str(exc))
         return self._spec
 
     def validate_content(self) -> None:
         super().validate_content()
         if self.kind != InfrahubFileKind.OBJECT:
             raise ValueError("File is not an Infrahub Object file")
-        self._spec = InfrahubObjectFileData(**self.data.spec)
+        try:
+            self._spec = InfrahubObjectFileData(**self.data.spec)
+        except Exception as exc:
+            raise ValidationError(identifier=str(self.location), message=str(exc))
 
     async def validate_format(self, client: InfrahubClient, branch: str | None = None) -> None:
         self.validate_content()

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

infrahub_sdk/spec/processors/range_expand_processor.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import copy
+import logging
+import re
+from typing import Any
+
+from ...exceptions import ValidationError
+from ..range_expansion import MATCH_PATTERN, range_expansion
+from .data_processor import DataProcessor
+
+log = logging.getLogger("infrahub_sdk")
+
+
+class RangeExpandDataProcessor(DataProcessor):
+    """Process data with range expansion"""
+
+    @classmethod
+    async def process_data(
+        cls,
+        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 (ValueError, TypeError, KeyError):
+                        # If expansion fails, treat as no expansion
+                        log.debug(
+                            f"Range expansion failed for value '{value}' in key '{key}'. Treating 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(
+                    identifier="range_expansion",
+                    message=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

infrahub_sdk/spec/range_expansion.py

@@ -0,0 +1,118 @@
+import itertools
+import re
+
+MATCH_PATTERN = r"(\[[\w,-]*[-,][\w,-]*\])"
+
+
+def _escape_brackets(s: str) -> str:
+    return s.replace("\\[", "__LBRACK__").replace("\\]", "__RBRACK__")
+
+
+def _unescape_brackets(s: str) -> str:
+    return s.replace("__LBRACK__", "[").replace("__RBRACK__", "]")
+
+
+def _char_range_expand(char_range_str: str) -> list[str]:
+    """Expands a string of numbers or single-character letters."""
+    expanded_values: list[str] = []
+    # Special case: if no dash and no comma, and multiple characters, error if not all alphanumeric
+    if "," not in char_range_str and "-" not in char_range_str and len(char_range_str) > 1:
+        if not char_range_str.isalnum():
+            raise ValueError(f"Invalid non-alphanumeric range: [{char_range_str}]")
+        return list(char_range_str)
+
+    for value in char_range_str.split(","):
+        if not value:
+            # Malformed: empty part in comma-separated list
+            return [f"[{char_range_str}]"]
+        if "-" in value:
+            start_char, end_char = value.split("-", 1)
+            if not start_char or not end_char:
+                expanded_values.append(f"[{char_range_str}]")
+                return expanded_values
+            # Check if it's a numeric range
+            if start_char.isdigit() and end_char.isdigit():
+                start_num = int(start_char)
+                end_num = int(end_char)
+                step = 1 if start_num <= end_num else -1
+                expanded_values.extend(str(i) for i in range(start_num, end_num + step, step))
+            # Check if it's an alphabetical range (single character)
+            elif len(start_char) == 1 and len(end_char) == 1 and start_char.isalpha() and end_char.isalpha():
+                start_ord = ord(start_char)
+                end_ord = ord(end_char)
+                step = 1 if start_ord <= end_ord else -1
+                is_upper = start_char.isupper()
+                for i in range(start_ord, end_ord + step, step):
+                    char = chr(i)
+                    expanded_values.append(char.upper() if is_upper else char)
+            else:
+                # Mixed or unsupported range type, append as-is
+                expanded_values.append(value)
+        else:
+            # If the value is a single character or valid alphanumeric string, append
+            if not value.isalnum():
+                raise ValueError(f"Invalid non-alphanumeric value: [{value}]")
+            expanded_values.append(value)
+    return expanded_values
+
+
+def _extract_constants(pattern: str, re_compiled: re.Pattern) -> tuple[list[int], list[list[str]]]:
+    cartesian_list = []
+    interface_constant = [0]
+    for match in re_compiled.finditer(pattern):
+        interface_constant.append(match.start())
+        interface_constant.append(match.end())
+        cartesian_list.append(_char_range_expand(match.group()[1:-1]))
+    return interface_constant, cartesian_list
+
+
+def _expand_interfaces(pattern: str, interface_constant: list[int], cartesian_list: list[list[str]]) -> list[str]:
+    def _pairwise(lst: list[int]) -> list[tuple[int, int]]:
+        it = iter(lst)
+        return list(zip(it, it))
+
+    if interface_constant[-1] < len(pattern):
+        interface_constant.append(len(pattern))
+    interface_constant_out = _pairwise(interface_constant)
+    expanded_interfaces = []
+    for element in itertools.product(*cartesian_list):
+        current_interface = ""
+        for count, item in enumerate(interface_constant_out):
+            current_interface += pattern[item[0] : item[1]]
+            if count < len(element):
+                current_interface += element[count]
+        expanded_interfaces.append(_unescape_brackets(current_interface))
+    return expanded_interfaces
+
+
+def range_expansion(interface_pattern: str) -> list[str]:
+    """Expand string pattern into a list of strings, supporting both
+    number and single-character alphabet ranges. Heavily inspired by
+    Netutils interface_range_expansion but adapted to support letters.
+
+    Args:
+        interface_pattern: The string pattern that will be parsed to create the list of interfaces.
+
+    Returns:
+        Contains the expanded list of interfaces.
+
+    Examples:
+        >>> from infrahub_sdk.spec.range_expansion import range_expansion
+        >>> range_expansion("Device [A-C]")
+        ['Device A', 'Device B', 'Device C']
+        >>> range_expansion("FastEthernet[1-2]/0/[10-15]")
+        ['FastEthernet1/0/10', 'FastEthernet1/0/11', 'FastEthernet1/0/12',
+        'FastEthernet1/0/13', 'FastEthernet1/0/14', 'FastEthernet1/0/15',
+        'FastEthernet2/0/10', 'FastEthernet2/0/11', 'FastEthernet2/0/12',
+        'FastEthernet2/0/13', 'FastEthernet2/0/14', 'FastEthernet2/0/15']
+        >>> range_expansion("GigabitEthernet[a-c]/0/1")
+        ['GigabitEtherneta/0/1', 'GigabitEthernetb/0/1', 'GigabitEthernetc/0/1']
+        >>> range_expansion("Eth[a,c,e]/0/1")
+        ['Etha/0/1', 'Ethc/0/1', 'Ethe/0/1']
+    """
+    pattern_escaped = _escape_brackets(interface_pattern)
+    re_compiled = re.compile(MATCH_PATTERN)
+    if not re_compiled.search(pattern_escaped):
+        return [_unescape_brackets(pattern_escaped)]
+    interface_constant, cartesian_list = _extract_constants(pattern_escaped, re_compiled)
+    return _expand_interfaces(pattern_escaped, interface_constant, cartesian_list)

infrahub_sdk/task/models.py

@@ -49,12 +49,14 @@ class Task(BaseModel):
         related_nodes: list[TaskRelatedNode] = []
         logs: list[TaskLog] = []
 
-        if data.get("related_nodes"):
-            related_nodes = [TaskRelatedNode(**item) for item in data["related_nodes"]]
+        if "related_nodes" in data:
+            if data.get("related_nodes"):
+                related_nodes = [TaskRelatedNode(**item) for item in data["related_nodes"]]
             del data["related_nodes"]
 
-        if data.get("logs"):
-            logs = [TaskLog(**item["node"]) for item in data["logs"]["edges"]]
+        if "logs" in data:
+            if data.get("logs"):
+                logs = [TaskLog(**item["node"]) for item in data["logs"]["edges"]]
             del data["logs"]
 
         return cls(**data, related_nodes=related_nodes, logs=logs)

infrahub_sdk/timestamp.py

@@ -3,14 +3,22 @@ from __future__ import annotations
 import re
 import warnings
 from datetime import datetime, timezone
-from typing import Literal
+from typing import Literal, TypedDict
 
+from typing_extensions import NotRequired
 from whenever import Date, Instant, LocalDateTime, OffsetDateTime, Time, ZonedDateTime
 
 from .exceptions import TimestampFormatError
 
 UTC = timezone.utc  # Required for older versions of Python
 
+
+class SubstractParams(TypedDict):
+    seconds: NotRequired[float]
+    minutes: NotRequired[float]
+    hours: NotRequired[float]
+
+
 REGEX_MAPPING = {
     "seconds": r"(\d+)(s|sec|second|seconds)",
     "minutes": r"(\d+)(m|min|minute|minutes)",
@@ -43,8 +51,7 @@ class Timestamp:
     @classmethod
     def _parse_string(cls, value: str) -> ZonedDateTime:
         try:
-            zoned_date = ZonedDateTime.parse_common_iso(value)
-            return zoned_date
+            return ZonedDateTime.parse_common_iso(value)
         except ValueError:
             pass
 
@@ -73,14 +80,19 @@ class Timestamp:
         except ValueError:
             pass
 
-        params: dict[str, float] = {}
+        params: SubstractParams = {}
         for key, regex in REGEX_MAPPING.items():
             match = re.search(regex, value)
             if match:
-                params[key] = float(match.group(1))
+                if key == "seconds":
+                    params["seconds"] = float(match.group(1))
+                elif key == "minutes":
+                    params["minutes"] = float(match.group(1))
+                elif key == "hours":
+                    params["hours"] = float(match.group(1))
 
         if params:
-            return ZonedDateTime.now("UTC").subtract(**params)  # type: ignore[call-overload]
+            return ZonedDateTime.now("UTC").subtract(**params)
 
         raise TimestampFormatError(f"Invalid time format for {value}")
 

infrahub_sdk/transforms.py

@@ -17,7 +17,7 @@ INFRAHUB_TRANSFORM_VARIABLE_TO_IMPORT = "INFRAHUB_TRANSFORMS"
 class InfrahubTransform(InfrahubOperation):
     name: str | None = None
     query: str
-    timeout: int = 10
+    timeout: int = 60
 
     def __init__(
         self,

{infrahub_server-1.4.12.dist-info → infrahub_server-1.5.0.dist-info}/METADATA

@@ -1,25 +1,25 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.4.12
+Version: 1.5.0
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: Apache-2.0
 Author: OpsMill
 Author-email: info@opsmill.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.12,<3.13
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: Jinja2 (>=3,<4)
 Requires-Dist: aio-pika (>=9.4,<9.5)
 Requires-Dist: aiodataloader (==0.4.0)
+Requires-Dist: ariadne-codegen (==0.15.3)
 Requires-Dist: asgi-correlation-id (==4.2.0)
 Requires-Dist: authlib (==1.6.5)
 Requires-Dist: bcrypt (>=4.1,<4.2)
 Requires-Dist: boto3 (==1.34.129)
 Requires-Dist: cachetools-async (>=0.0.5,<0.0.6)
+Requires-Dist: click (==8.1.7)
 Requires-Dist: copier (>=9.8.0,<10.0.0)
 Requires-Dist: dulwich (>=0.22.7,<0.23.0)
 Requires-Dist: email-validator (>=2.1,<2.2)
@@ -35,15 +35,14 @@ Requires-Dist: neo4j (>=5.28,<5.29)
 Requires-Dist: neo4j-rust-ext (>=5.28,<5.29)
 Requires-Dist: netaddr (==1.3.0)
 Requires-Dist: netutils (==1.12.0)
-Requires-Dist: numpy (>=1.24.2,<2.0.0) ; python_version >= "3.9" and python_version < "3.12"
-Requires-Dist: numpy (>=1.26.2,<2.0.0) ; python_version >= "3.12"
+Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (==1.28.1)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (==1.28.1)
 Requires-Dist: opentelemetry-instrumentation-aio-pika (==0.49b1)
 Requires-Dist: opentelemetry-instrumentation-fastapi (==0.49b1)
-Requires-Dist: prefect (==3.4.13)
-Requires-Dist: prefect-redis (==0.2.4)
-Requires-Dist: pyarrow (>=14,<15)
+Requires-Dist: prefect (==3.4.23)
+Requires-Dist: prefect-redis (==0.2.5)
+Requires-Dist: pyarrow (>=14)
 Requires-Dist: pydantic (>=2.10,<2.11)
 Requires-Dist: pydantic-settings (>=2.8,<2.9)
 Requires-Dist: pyjwt (>=2.8,<2.9)
@@ -54,7 +53,7 @@ Requires-Dist: redis[hiredis] (>=6.0.0,<7.0.0)
 Requires-Dist: rich (>=13,<14)
 Requires-Dist: starlette-exporter (>=0.23,<0.24)
 Requires-Dist: structlog (==24.1.0)
-Requires-Dist: toml (>=0.10,<0.11)
+Requires-Dist: tomli (>=1.1.0) ; python_version < "3.11"
 Requires-Dist: typer (==0.12.5)
 Requires-Dist: ujson (>=5,<6)
 Requires-Dist: uvicorn[standard] (>=0.32,<0.33)