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

infrahub/core/schema/attribute_parameters.py

@@ -1,21 +1,27 @@
 from __future__ import annotations
 
-from pydantic import Field
+import sys
+from typing import Self
 
+from pydantic import ConfigDict, Field, model_validator
+
+from infrahub import config
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.models import HashableModel
 
 
 def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParameters]:
-    return {
+    param_classes: dict[str, type[AttributeParameters]] = {
+        "NumberPool": NumberPoolParameters,
         "Text": TextAttributeParameters,
         "TextArea": TextAttributeParameters,
-    }.get(kind, AttributeParameters)
+        "Number": NumberAttributeParameters,
+    }
+    return param_classes.get(kind, AttributeParameters)
 
 
 class AttributeParameters(HashableModel):
-    class Config:
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")
 
 
 class TextAttributeParameters(AttributeParameters):
@@ -34,3 +40,121 @@ class TextAttributeParameters(AttributeParameters):
         description="Set a maximum number of characters allowed.",
         json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
     )
+
+    @model_validator(mode="after")
+    def validate_min_max(self) -> Self:
+        if (
+            config.SETTINGS.initialized
+            and config.SETTINGS.main.schema_strict_mode
+            and self.min_length is not None
+            and self.max_length is not None
+        ):
+            if self.min_length > self.max_length:
+                raise ValueError(
+                    "`max_length` can't be less than `min_length` when the schema is configured with strict mode"
+                )
+
+        return self
+
+
+class NumberAttributeParameters(AttributeParameters):
+    min_value: int | None = Field(
+        default=None,
+        description="Set a minimum value allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    max_value: int | None = Field(
+        default=None,
+        description="Set a maximum value allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    excluded_values: str | None = Field(
+        default=None,
+        description="List of values or range of values not allowed for the attribute, format is: '100,150-200,280,300-400'",
+        pattern=r"^(\d+(?:-\d+)?)(?:,\d+(?:-\d+)?)*$",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+    @model_validator(mode="after")
+    def validate_ranges(self) -> Self:
+        ranges = self.get_excluded_ranges()
+        for i, (start_range_1, end_range_1) in enumerate(ranges):
+            if start_range_1 > end_range_1:
+                raise ValueError("`start_range` can't be less than `end_range`")
+
+            # Check for overlapping ranges
+            for start_range_2, end_range_2 in ranges[i + 1 :]:
+                if not (end_range_1 < start_range_2 or start_range_1 > end_range_2):
+                    raise ValueError("Excluded ranges cannot overlap")
+
+        return self
+
+    @model_validator(mode="after")
+    def validate_min_max(self) -> Self:
+        if (
+            config.SETTINGS.initialized
+            and config.SETTINGS.main.schema_strict_mode
+            and self.min_value is not None
+            and self.max_value is not None
+        ):
+            if self.min_value > self.max_value:
+                raise ValueError(
+                    "`max_value` can't be less than `min_value` when the schema is configured with strict mode"
+                )
+
+        return self
+
+    def get_excluded_single_values(self) -> list[int]:
+        if not self.excluded_values:
+            return []
+
+        results = [int(value) for value in self.excluded_values.split(",") if "-" not in value]
+        return results
+
+    def get_excluded_ranges(self) -> list[tuple[int, int]]:
+        if not self.excluded_values:
+            return []
+
+        ranges = []
+        for value in self.excluded_values.split(","):
+            if "-" in value:
+                start, end = map(int, value.split("-"))
+                ranges.append((start, end))
+
+        return ranges
+
+    def is_valid_value(self, value: int) -> bool:
+        if self.min_value is not None and value < self.min_value:
+            return False
+        if self.max_value is not None and value > self.max_value:
+            return False
+        if value in self.get_excluded_single_values():
+            return False
+        for start, end in self.get_excluded_ranges():
+            if start <= value <= end:
+                return False
+        return True
+
+
+class NumberPoolParameters(AttributeParameters):
+    end_range: int = Field(
+        default=sys.maxsize,
+        description="End range for numbers for the associated NumberPool",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    start_range: int = Field(
+        default=1,
+        description="Start range for numbers for the associated NumberPool",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    number_pool_id: str | None = Field(
+        default=None,
+        description="The ID of the numberpool associated with this attribute",
+        json_schema_extra={"update": UpdateSupport.NOT_SUPPORTED.value},
+    )
+
+    @model_validator(mode="after")
+    def validate_ranges(self) -> Self:
+        if self.start_range > self.end_range:
+            raise ValueError("`start_range` can't be less than `end_range`")
+        return self

infrahub/core/schema/attribute_schema.py

@@ -12,7 +12,13 @@ from infrahub.core.enums import generate_python_enum
 from infrahub.core.query.attribute import default_attribute_query_filter
 from infrahub.types import ATTRIBUTE_KIND_LABELS, ATTRIBUTE_TYPES
 
-from .attribute_parameters import AttributeParameters, TextAttributeParameters, get_attribute_parameters_class_for_kind
+from .attribute_parameters import (
+    AttributeParameters,
+    NumberAttributeParameters,
+    NumberPoolParameters,
+    TextAttributeParameters,
+    get_attribute_parameters_class_for_kind,
+)
 from .generated.attribute_schema import GeneratedAttributeSchema
 
 if TYPE_CHECKING:
@@ -24,10 +30,6 @@ if TYPE_CHECKING:
 
 
 def get_attribute_schema_class_for_kind(kind: str) -> type[AttributeSchema]:
-    attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
-        "Text": TextAttributeSchema,
-        "TextArea": TextAttributeSchema,
-    }
     return attribute_schema_class_by_kind.get(kind, AttributeSchema)
 
 
@@ -35,6 +37,24 @@ class AttributeSchema(GeneratedAttributeSchema):
     _sort_by: list[str] = ["name"]
     _enum_class: type[enum.Enum] | None = None
 
+    @classmethod
+    def model_json_schema(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        schema = super().model_json_schema(*args, **kwargs)
+
+        # Build conditional schema based on attribute_schema_class_by_kind mapping
+        # This override allows people using the Yaml language server to get the correct mappings
+        # for the parameters when selecting the appropriate kind
+        schema["allOf"] = []
+        for kind, schema_class in attribute_schema_class_by_kind.items():
+            schema["allOf"].append(
+                {
+                    "if": {"properties": {"kind": {"const": kind}}},
+                    "then": {"properties": {"parameters": {"$ref": f"#/definitions/{schema_class.__name__}"}}},
+                }
+            )
+
+        return schema
+
     @property
     def is_attribute(self) -> bool:
         return True
@@ -93,6 +113,16 @@ class AttributeSchema(GeneratedAttributeSchema):
             return expected_parameters_class(**value.model_dump())
         return value
 
+    @model_validator(mode="after")
+    def validate_parameters(self) -> Self:
+        if isinstance(self.parameters, NumberPoolParameters) and not self.kind == "NumberPool":
+            raise ValueError(f"NumberPoolParameters can't be used as parameters for {self.kind}")
+
+        if isinstance(self.parameters, TextAttributeParameters) and self.kind not in ["Text", "TextArea"]:
+            raise ValueError(f"TextAttributeParameters can't be used as parameters for {self.kind}")
+
+        return self
+
     def get_class(self) -> type[BaseAttribute]:
         return ATTRIBUTE_TYPES[self.kind].get_infrahub_class()
 
@@ -185,6 +215,14 @@ class AttributeSchema(GeneratedAttributeSchema):
         )
 
 
+class NumberPoolSchema(AttributeSchema):
+    parameters: NumberPoolParameters = Field(
+        default_factory=NumberPoolParameters,
+        description="Extra parameters specific to NumberPool attributes",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+
 class TextAttributeSchema(AttributeSchema):
     parameters: TextAttributeParameters = Field(
         default_factory=TextAttributeParameters,
@@ -195,19 +233,13 @@ class TextAttributeSchema(AttributeSchema):
     @model_validator(mode="after")
     def reconcile_parameters(self) -> Self:
         if self.regex != self.parameters.regex:
-            final_regex = self.parameters.regex or self.regex
-            if not final_regex:  # falsy parameters.regex override falsy regex
-                final_regex = self.parameters.regex
+            final_regex = self.parameters.regex if self.parameters.regex is not None else self.regex
             self.regex = self.parameters.regex = final_regex
         if self.min_length != self.parameters.min_length:
-            final_min_length = self.parameters.min_length or self.min_length
-            if not final_min_length:  # falsy parameters.min_length override falsy min_length
-                final_min_length = self.parameters.min_length
+            final_min_length = self.parameters.min_length if self.parameters.min_length is not None else self.min_length
             self.min_length = self.parameters.min_length = final_min_length
         if self.max_length != self.parameters.max_length:
-            final_max_length = self.parameters.max_length or self.max_length
-            if not final_max_length:  # falsy parameters.max_length override falsy max_length
-                final_max_length = self.parameters.max_length
+            final_max_length = self.parameters.max_length if self.parameters.max_length is not None else self.max_length
             self.max_length = self.parameters.max_length = final_max_length
         return self
 
@@ -219,3 +251,19 @@ class TextAttributeSchema(AttributeSchema):
 
     def get_max_length(self) -> int | None:
         return self.parameters.max_length
+
+
+class NumberAttributeSchema(AttributeSchema):
+    parameters: NumberAttributeParameters = Field(
+        default_factory=NumberAttributeParameters,
+        description="Extra parameters specific to number attributes",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+
+attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
+    "NumberPool": NumberPoolSchema,
+    "Text": TextAttributeSchema,
+    "TextArea": TextAttributeSchema,
+    "Number": NumberAttributeSchema,
+}

infrahub/core/schema/basenode_schema.py

@@ -386,7 +386,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.display_labels:
             return None
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         for item in self.display_labels:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
@@ -401,7 +401,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.human_friendly_id:
             return None
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         for item in self.human_friendly_id:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields

infrahub/core/schema/definitions/core/__init__.py

@@ -28,7 +28,13 @@ from .check import core_check_definition
 from .core import core_node, core_task_target
 from .generator import core_generator_definition, core_generator_instance
 from .graphql_query import core_graphql_query
-from .group import core_generator_group, core_graphql_query_group, core_group, core_standard_group
+from .group import (
+    core_generator_group,
+    core_graphql_query_group,
+    core_group,
+    core_repository_group,
+    core_standard_group,
+)
 from .ipam import builtin_ip_address, builtin_ip_prefix, builtin_ipam, core_ipam_namespace
 from .lineage import lineage_owner, lineage_source
 from .menu import generic_menu_item, menu_item
@@ -68,7 +74,13 @@ from .propose_change_validator import (
     core_user_validator,
 )
 from .repository import core_generic_repository, core_read_only_repository, core_repository
-from .resource_pool import core_ip_address_pool, core_ip_prefix_pool, core_number_pool, core_resource_pool
+from .resource_pool import (
+    core_ip_address_pool,
+    core_ip_prefix_pool,
+    core_number_pool,
+    core_resource_pool,
+    core_weighted_pool_resource,
+)
 from .template import core_object_component_template, core_object_template
 from .transform import core_transform, core_transform_jinja2, core_transform_python
 from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
@@ -96,6 +108,7 @@ core_models_mixed: dict[str, list] = {
         builtin_ip_prefix,
         builtin_ip_address,
         core_resource_pool,
+        core_weighted_pool_resource,
         core_generic_account,
         core_base_permission,
         core_credential,
@@ -109,6 +122,7 @@ core_models_mixed: dict[str, list] = {
         core_standard_group,
         core_generator_group,
         core_graphql_query_group,
+        core_repository_group,
         builtin_tag,
         core_account,
         core_account_token,

infrahub/core/schema/definitions/core/group.py

@@ -1,9 +1,11 @@
 from infrahub.core.constants import (
     BranchSupportType,
     InfrahubKind,
+    RepositoryObjects,
 )
 from infrahub.core.constants import RelationshipCardinality as Cardinality
 from infrahub.core.constants import RelationshipKind as RelKind
+from infrahub.core.schema.dropdown import DropdownChoice
 
 from ...attribute_schema import AttributeSchema as Attr
 from ...generic_schema import GenericSchema
@@ -80,6 +82,7 @@ core_generator_group = NodeSchema(
     generate_profile=False,
 )
 
+
 core_graphql_query_group = NodeSchema(
     name="GraphQLQueryGroup",
     namespace="Core",
@@ -106,3 +109,45 @@ core_graphql_query_group = NodeSchema(
         ),
     ],
 )
+
+
+core_repository_group = NodeSchema(
+    name="RepositoryGroup",
+    namespace="Core",
+    description="Group of nodes associated with a given repository.",
+    include_in_menu=False,
+    icon="mdi:account-group",
+    label="Repository Group",
+    default_filter="name__value",
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.LOCAL,
+    inherit_from=[InfrahubKind.GENERICGROUP],
+    generate_profile=False,
+    attributes=[
+        Attr(
+            name="content",
+            kind="Dropdown",
+            description="Type of data to load, can be either `object` or `menu`",
+            choices=[
+                DropdownChoice(
+                    name=RepositoryObjects.OBJECT.value,
+                    label="Objects",
+                ),
+                DropdownChoice(
+                    name=RepositoryObjects.MENU.value,
+                    label="Menus",
+                ),
+            ],
+            optional=False,
+        ),
+    ],
+    relationships=[
+        Rel(
+            name="repository",
+            peer=InfrahubKind.GENERICREPOSITORY,
+            optional=False,
+            cardinality=Cardinality.ONE,
+        ),
+    ],
+)

infrahub/core/schema/definitions/core/resource_pool.py

@@ -1,6 +1,7 @@
 from infrahub.core.constants import (
     BranchSupportType,
     InfrahubKind,
+    NumberPoolType,
 )
 from infrahub.core.constants import RelationshipCardinality as Cardinality
 from infrahub.core.constants import RelationshipKind as RelKind
@@ -32,6 +33,26 @@ core_resource_pool = GenericSchema(
     ],
 )
 
+core_weighted_pool_resource = GenericSchema(
+    name="WeightedPoolResource",
+    namespace="Core",
+    label="Weighted Pool Resource",
+    description="Resource to be used in a pool, its weight is used to determine its priority on allocation.",
+    include_in_menu=False,
+    branch=BranchSupportType.AWARE,
+    generate_profile=False,
+    attributes=[
+        Attr(
+            name="allocation_weight",
+            label="Weight",
+            description="Weight determines allocation priority, resources with higher values are selected first.",
+            kind="Number",
+            optional=True,
+            order_weight=10000,
+        )
+    ],
+)
+
 core_ip_prefix_pool = NodeSchema(
     name="IPPrefixPool",
     namespace="Core",
@@ -166,5 +187,13 @@ core_number_pool = NodeSchema(
         Attr(
             name="end_range", kind="Number", optional=False, description="The end range for the pool", order_weight=6000
         ),
+        Attr(
+            name="pool_type",
+            kind="Text",
+            description="Defines how this number pool was created",
+            default_value=NumberPoolType.USER.value,
+            enum=NumberPoolType.available_types(),
+            read_only=True,
+        ),
     ],
 )

infrahub/core/schema/definitions/internal.py

@@ -31,7 +31,12 @@ from infrahub.core.constants import (
     RelationshipKind,
     UpdateSupport,
 )
-from infrahub.core.schema.attribute_parameters import AttributeParameters
+from infrahub.core.schema.attribute_parameters import (
+    AttributeParameters,
+    NumberAttributeParameters,
+    NumberPoolParameters,
+    TextAttributeParameters,
+)
 from infrahub.core.schema.attribute_schema import AttributeSchema
 from infrahub.core.schema.computed_attribute import ComputedAttribute
 from infrahub.core.schema.dropdown import DropdownChoice
@@ -48,7 +53,7 @@ class SchemaAttribute(BaseModel):
     kind: str
     description: str
     extra: ExtraField
-    internal_kind: type[Any] | GenericAlias | None = None
+    internal_kind: type[Any] | GenericAlias | list[type[Any]] | None = None
     regex: str | None = None
     unique: bool | None = None
     optional: bool | None = None
@@ -77,7 +82,7 @@ class SchemaAttribute(BaseModel):
 
     @property
     def optional_in_model(self) -> bool:
-        if self.optional and self.default_value is None and self.default_factory is None or self.default_to_none:
+        if (self.optional and self.default_value is None and self.default_factory is None) or self.default_to_none:
             return True
 
         return False
@@ -94,6 +99,9 @@ class SchemaAttribute(BaseModel):
         if isinstance(self.internal_kind, GenericAlias):
             return str(self.internal_kind)
 
+        if isinstance(self.internal_kind, list):
+            return " | ".join([internal_kind.__name__ for internal_kind in self.internal_kind])
+
         if self.internal_kind and self.kind == "List":
             return f"list[{self.internal_kind.__name__}]"
 
@@ -621,7 +629,12 @@ attribute_schema = SchemaNode(
         SchemaAttribute(
             name="parameters",
             kind="JSON",
-            internal_kind=AttributeParameters,
+            internal_kind=[
+                AttributeParameters,
+                TextAttributeParameters,
+                NumberAttributeParameters,
+                NumberPoolParameters,
+            ],
             optional=True,
             description="Extra parameters specific to this kind of attribute",
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
@@ -741,6 +754,14 @@ relationship_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
+        SchemaAttribute(
+            name="common_relatives",
+            kind="List",
+            internal_kind=str,
+            optional=True,
+            description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
+            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+        ),
         SchemaAttribute(
             name="order_weight",
             kind="Number",

infrahub/core/schema/generated/attribute_schema.py

@@ -8,7 +8,12 @@ from pydantic import Field
 
 from infrahub.core.constants import AllowOverrideType, BranchSupportType, HashableModelState
 from infrahub.core.models import HashableModel
-from infrahub.core.schema.attribute_parameters import AttributeParameters  # noqa: TC001
+from infrahub.core.schema.attribute_parameters import (
+    AttributeParameters,
+    NumberAttributeParameters,
+    NumberPoolParameters,
+    TextAttributeParameters,
+)
 from infrahub.core.schema.computed_attribute import ComputedAttribute  # noqa: TC001
 from infrahub.core.schema.dropdown import DropdownChoice  # noqa: TC001
 
@@ -113,10 +118,12 @@ class GeneratedAttributeSchema(HashableModel):
         description="Type of allowed override for the attribute.",
         json_schema_extra={"update": "allowed"},
     )
-    parameters: AttributeParameters = Field(
-        default_factory=AttributeParameters,
-        description="Extra parameters specific to this kind of attribute",
-        json_schema_extra={"update": "validate_constraint"},
+    parameters: AttributeParameters | TextAttributeParameters | NumberAttributeParameters | NumberPoolParameters = (
+        Field(
+            default_factory=AttributeParameters,
+            description="Extra parameters specific to this kind of attribute",
+            json_schema_extra={"update": "validate_constraint"},
+        )
     )
     deprecation: str | None = Field(
         default=None,

infrahub/core/schema/generated/relationship_schema.py

@@ -12,7 +12,7 @@ from infrahub.core.constants import (
     RelationshipDeleteBehavior,
     RelationshipDirection,
     RelationshipKind,
-)  # noqa: TC001
+)
 from infrahub.core.models import HashableModel
 
 
@@ -73,6 +73,11 @@ class GeneratedRelationshipSchema(HashableModel):
         description="Defines the maximum objects allowed on the other side of the relationship.",
         json_schema_extra={"update": "validate_constraint"},
     )
+    common_relatives: list[str] | None = Field(
+        default=None,
+        description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
+        json_schema_extra={"update": "validate_constraint"},
+    )
     order_weight: int | None = Field(
         default=None,
         description="Number used to order the relationship in the frontend (table and view). Lowest value will be ordered first.",

infrahub/core/schema/manager.py

@@ -471,7 +471,7 @@ class SchemaManager(NodeManager):
         if diff_attributes:
             for item in node.local_attributes:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
-                if item.name in diff_attributes.added or item.name in diff_attributes.changed and item.id is None:
+                if item.name in diff_attributes.added or (item.name in diff_attributes.changed and item.id is None):
                     created_item = await self.create_attribute_in_db(
                         schema=attribute_schema, item=item, branch=branch, db=db, parent=obj
                     )
@@ -491,7 +491,9 @@ class SchemaManager(NodeManager):
         if diff_relationships:
             for item in node.local_relationships:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
-                if item.name in diff_relationships.added or item.name in diff_relationships.changed and item.id is None:
+                if item.name in diff_relationships.added or (
+                    item.name in diff_relationships.changed and item.id is None
+                ):
                     created_rel = await self.create_relationship_in_db(
                         schema=relationship_schema, item=item, branch=branch, db=db, parent=obj
                     )
@@ -764,3 +766,6 @@ class SchemaManager(NodeManager):
                 del self._cache[hash_key]
 
         return removed_branches
+
+    def get_branches(self) -> list[str]:
+        return list(self._branches.keys())