infrahub-server 1.5.0b1__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

infrahub_sdk/config.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import ssl
 from copy import deepcopy
 from typing import Any
 
-from pydantic import Field, field_validator, model_validator
+from pydantic import Field, PrivateAttr, field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing_extensions import Self
 
@@ -78,6 +79,7 @@ class ConfigBase(BaseSettings):
     Can be useful to test with self-signed certificates.""",
     )
     tls_ca_file: str | None = Field(default=None, description="File path to CA cert or bundle in PEM format")
+    _ssl_context: ssl.SSLContext | None = PrivateAttr(default=None)
 
     @model_validator(mode="before")
     @classmethod
@@ -133,6 +135,28 @@ class ConfigBase(BaseSettings):
     def password_authentication(self) -> bool:
         return bool(self.username)
 
+    @property
+    def tls_context(self) -> ssl.SSLContext:
+        if self._ssl_context:
+            return self._ssl_context
+
+        if self.tls_insecure:
+            self._ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            self._ssl_context.check_hostname = False
+            self._ssl_context.verify_mode = ssl.CERT_NONE
+            return self._ssl_context
+
+        if self.tls_ca_file:
+            self._ssl_context = ssl.create_default_context(cafile=self.tls_ca_file)
+
+        if self._ssl_context is None:
+            self._ssl_context = ssl.create_default_context()
+
+        return self._ssl_context
+
+    def set_ssl_context(self, context: ssl.SSLContext) -> None:
+        self._ssl_context = context
+
 
 class Config(ConfigBase):
     recorder: RecorderType = Field(default=RecorderType.NONE, description="Select builtin recorder for later replay.")
@@ -174,4 +198,7 @@ class Config(ConfigBase):
             if field not in covered_keys:
                 config[field] = deepcopy(getattr(self, field))
 
-        return Config(**config)
+        new_config = Config(**config)
+        if self._ssl_context:
+            new_config.set_ssl_context(self._ssl_context)
+        return new_config

infrahub_sdk/ctl/schema.py

@@ -14,6 +14,7 @@ from ..async_typer import AsyncTyper
 from ..ctl.client import initialize_client
 from ..ctl.utils import catch_exception, init_logging
 from ..queries import SCHEMA_HASH_SYNC_STATUS
+from ..schema import SchemaWarning
 from ..yaml import SchemaFile
 from .parameters import CONFIG_PARAM
 from .utils import load_yamlfile_from_disk_and_exit
@@ -152,6 +153,8 @@ async def load(
 
     console.print(f"[green] {len(schemas_data)} {schema_definition} processed in {loading_time:.3f} seconds.")
 
+    _display_schema_warnings(console=console, warnings=response.warnings)
+
     if response.schema_updated and wait:
         waited = 0
         continue_waiting = True
@@ -187,12 +190,24 @@ async def check(
 
     success, response = await client.schema.check(schemas=[item.payload for item in schemas_data], branch=branch)
 
-    if not success:
+    if not success or not response:
         display_schema_load_errors(response=response or {}, schemas_data=schemas_data)
+        return
+
+    for schema_file in schemas_data:
+        console.print(f"[green] schema '{schema_file.location}' is Valid!")
+
+    warnings = response.pop("warnings", [])
+    schema_warnings = [SchemaWarning.model_validate(warning) for warning in warnings]
+    _display_schema_warnings(console=console, warnings=schema_warnings)
+    if response == {"diff": {"added": {}, "changed": {}, "removed": {}}}:
+        print("No diff")
     else:
-        for schema_file in schemas_data:
-            console.print(f"[green] schema '{schema_file.location}' is Valid!")
-        if response == {"diff": {"added": {}, "changed": {}, "removed": {}}}:
-            print("No diff")
-        else:
-            print(yaml.safe_dump(data=response, indent=4))
+        print(yaml.safe_dump(data=response, indent=4))
+
+
+def _display_schema_warnings(console: Console, warnings: list[SchemaWarning]) -> None:
+    for warning in warnings:
+        console.print(
+            f"[yellow] {warning.type.value}: {warning.message} [{', '.join([kind.display for kind in warning.kinds])}]"
+        )

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,6 +91,26 @@ 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]
@@ -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(
@@ -304,8 +221,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 +272,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
-                        strategy=strategy,
+                        parameters=parameters,
                     )
                 )
 
@@ -370,8 +288,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 +318,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
             )
             return errors
@@ -412,11 +332,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 +347,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
-                        strategy=strategy,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -452,6 +372,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -478,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(
@@ -489,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]
@@ -534,6 +458,7 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=parameters,
                         )
                         clean_data[key] = nodes[0]
 
@@ -545,6 +470,7 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=parameters,
                         )
                         clean_data[key] = nodes
 
@@ -583,6 +509,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
 
         return node
@@ -598,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 {}
 
@@ -618,6 +547,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
             return [new_node]
 
@@ -631,7 +561,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 +576,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                     nodes.append(node)
             return nodes
@@ -668,6 +602,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

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_server-1.5.0b1.dist-info → infrahub_server-1.5.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.5.0b1
+Version: 1.5.0b2
 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
@@ -18,6 +18,8 @@ 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)