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

infrahub/core/node/resource_manager/number_pool.py

@@ -2,22 +2,44 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub.core import registry
 from infrahub.core.query.resource_manager import NumberPoolGetReserved, NumberPoolGetUsed, NumberPoolSetReserved
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.exceptions import PoolExhaustedError
 
 from .. import Node
 
 if TYPE_CHECKING:
+    from infrahub.core.attribute import BaseAttribute
     from infrahub.core.branch import Branch
     from infrahub.database import InfrahubDatabase
 
 
 class CoreNumberPool(Node):
+    def get_attribute_nb_excluded_values(self) -> int:
+        """
+        Returns the number of excluded values for the attribute of the number pool.
+        """
+
+        pool_node = registry.schema.get(name=self.node.value)  # type: ignore [attr-defined]
+        attribute = [attribute for attribute in pool_node.attributes if attribute.name == self.node_attribute.value][0]  # type: ignore [attr-defined]
+        if not isinstance(attribute.parameters, NumberAttributeParameters):
+            return 0
+
+        sum_excluded_values = 0
+        excluded_ranges = attribute.parameters.get_excluded_ranges()
+        for start_range, end_range in excluded_ranges:
+            sum_excluded_values += end_range - start_range + 1
+
+        res = len(attribute.parameters.get_excluded_single_values()) + sum_excluded_values
+        return res
+
     async def get_resource(
         self,
         db: InfrahubDatabase,
         branch: Branch,
         node: Node,
+        attribute: BaseAttribute,
         identifier: str | None = None,
     ) -> int:
         identifier = identifier or node.get_id()
@@ -31,23 +53,24 @@ class CoreNumberPool(Node):
             return reservation
 
         # If we have not returned a value we need to find one if avaiable
-        number = await self.get_next(db=db, branch=branch)
+        number = await self.get_next(db=db, branch=branch, attribute=attribute)
 
         query_set = await NumberPoolSetReserved.init(
             db=db, pool_id=self.get_id(), identifier=identifier, reserved=number
         )
         await query_set.execute(db=db)
-
         return number
 
-    async def get_next(self, db: InfrahubDatabase, branch: Branch) -> int:
+    async def get_next(self, db: InfrahubDatabase, branch: Branch, attribute: BaseAttribute) -> int:
         query = await NumberPoolGetUsed.init(db=db, branch=branch, pool=self, branch_agnostic=True)
         await query.execute(db=db)
         taken = [result.get_as_optional_type("av.value", return_type=int) for result in query.results]
+        parameters = attribute.schema.parameters
         next_number = find_next_free(
             start=self.start_range.value,  # type: ignore[attr-defined]
             end=self.end_range.value,  # type: ignore[attr-defined]
             taken=taken,
+            parameters=parameters if isinstance(parameters, NumberAttributeParameters) else None,
         )
         if next_number is None:
             raise PoolExhaustedError("There are no more values available in this pool.")
@@ -55,12 +78,15 @@ class CoreNumberPool(Node):
         return next_number
 
 
-def find_next_free(start: int, end: int, taken: list[int | None]) -> int | None:
+def find_next_free(
+    start: int, end: int, taken: list[int | None], parameters: NumberAttributeParameters | None
+) -> int | None:
     used_numbers = [number for number in taken if number is not None]
     used_set = set(used_numbers)
 
     for num in range(start, end + 1):
         if num not in used_set:
-            return num
+            if parameters is None or parameters.is_valid_value(num):
+                return num
 
     return None

infrahub/core/node/standard.py

@@ -210,7 +210,12 @@ class StandardNode(BaseModel):
 
     @classmethod
     async def get_list(
-        cls, db: InfrahubDatabase, limit: int = 1000, ids: list[str] | None = None, name: str | None = None, **kwargs
+        cls,
+        db: InfrahubDatabase,
+        limit: int = 1000,
+        ids: list[str] | None = None,
+        name: str | None = None,
+        **kwargs: dict[str, Any],
     ) -> list[Self]:
         query: Query = await StandardNodeGetListQuery.init(
             db=db, node_class=cls, ids=ids, node_name=name, limit=limit, **kwargs

infrahub/core/protocols.py

@@ -227,6 +227,10 @@ class CoreWebhook(CoreNode):
     validate_certificates: BooleanOptional
 
 
+class CoreWeightedPoolResource(CoreNode):
+    allocation_weight: IntegerOptional
+
+
 class LineageOwner(CoreNode):
     pass
 
@@ -493,6 +497,11 @@ class CoreRepository(LineageOwner, LineageSource, CoreGenericRepository, CoreTas
     commit: StringOptional
 
 
+class CoreRepositoryGroup(CoreGroup):
+    content: Dropdown
+    repository: RelationshipManager
+
+
 class CoreRepositoryValidator(CoreValidator):
     repository: RelationshipManager
 

infrahub/core/query/relationship.py

@@ -217,8 +217,7 @@ class RelationshipQuery(Query):
         )
         source_query_match = """
             MATCH (s:Node { uuid: $source_id })
-            CALL {
-                WITH s
+            CALL (s) {
                 MATCH (s)-[r:IS_PART_OF]->(:Root)
                 WHERE %(source_filter)s
                 RETURN r.status = "active" AS s_is_active
@@ -246,8 +245,7 @@ class RelationshipQuery(Query):
             )
             destination_query_match = """
             MATCH (d:Node { uuid: $destination_id })
-            CALL {
-                WITH d
+            CALL (d) {
                 MATCH (d)-[r:IS_PART_OF]->(:Root)
                 WHERE %(destination_filter)s
                 RETURN r.status = "active" AS d_is_active

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:
@@ -25,8 +31,10 @@ if TYPE_CHECKING:
 
 def get_attribute_schema_class_for_kind(kind: str) -> type[AttributeSchema]:
     attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
+        "NumberPool": NumberPoolSchema,
         "Text": TextAttributeSchema,
         "TextArea": TextAttributeSchema,
+        "Number": NumberAttributeSchema,
     }
     return attribute_schema_class_by_kind.get(kind, AttributeSchema)
 
@@ -93,6 +101,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 +203,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 +221,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 +239,11 @@ 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},
+    )

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

@@ -32,6 +32,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",

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
@@ -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},

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,  # noqa: TC001
+    NumberAttributeParameters,  # noqa: TC001
+    NumberPoolParameters,  # noqa: TC001
+    TextAttributeParameters,  # noqa: TC001
+)
 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/manager.py

@@ -764,3 +764,6 @@ class SchemaManager(NodeManager):
                 del self._cache[hash_key]
 
         return removed_branches
+
+    def get_branches(self) -> list[str]:
+        return list(self._branches.keys())