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

infrahub/core/attribute.py

@@ -93,8 +93,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         updated_at: Timestamp | str | None = None,
         is_default: bool = False,
         is_from_profile: bool = False,
-        **kwargs,
-    ):
+        **kwargs: dict[str, Any],
+    ) -> None:
         self.id = id
         self.db_id = db_id
 
@@ -169,7 +169,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         return self.branch
 
     @classmethod
-    def __init_subclass__(cls, **kwargs) -> None:
+    def __init_subclass__(cls, **kwargs: dict[str, Any]) -> None:
         super().__init_subclass__(**kwargs)
         registry.attribute[cls.__name__] = cls
 

infrahub/core/constants/__init__.py

@@ -146,6 +146,11 @@ class AllowOverrideType(InfrahubStringEnum):
     ANY = "any"
 
 
+class RepositoryObjects(InfrahubStringEnum):
+    OBJECT = "object"
+    MENU = "menu"
+
+
 class ContentType(InfrahubStringEnum):
     APPLICATION_JSON = "application/json"
     APPLICATION_YAML = "application/yaml"

infrahub/core/constants/infrahubkind.py

@@ -58,6 +58,7 @@ PROFILE = "CoreProfile"
 PROPOSEDCHANGE = "CoreProposedChange"
 REFRESHTOKEN = "InternalRefreshToken"
 REPOSITORY = "CoreRepository"
+REPOSITORYGROUP = "CoreRepositoryGroup"
 RESOURCEPOOL = "CoreResourcePool"
 GENERICREPOSITORY = "CoreGenericRepository"
 READONLYREPOSITORY = "CoreReadOnlyRepository"
@@ -78,3 +79,4 @@ TRIGGERRULE = "CoreTriggerRule"
 USERVALIDATOR = "CoreUserValidator"
 VALIDATOR = "CoreValidator"
 WEBHOOK = "CoreWebhook"
+WEIGHTED_POOL_RESOURCE = "CoreWeightedPoolResource"

infrahub/core/migrations/query/attribute_rename.py

@@ -55,7 +55,6 @@ class AttributeRenameQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type_update_active(rel_type: str, rel_def: FieldInfo) -> str:
         subquery = [
-            "WITH peer_node, rb, active_attr",
             "WITH peer_node, rb, active_attr",
             f'WHERE type(rb) = "{rel_type}"',
         ]
@@ -72,7 +71,6 @@ class AttributeRenameQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type_create_new(rel_type: str, rel_def: FieldInfo) -> str:
         subquery = [
-            "WITH peer_node, rb, active_attr, new_attr",
             "WITH peer_node, rb, active_attr, new_attr",
             f'WHERE type(rb) = "{rel_type}"',
         ]
@@ -158,7 +156,7 @@ class AttributeRenameQuery(Query):
         }
         WITH a1 as active_attr, r1 as rb, p1 as peer_node, new_attr
         WHERE rb.status = "active"
-        CALL {
+        CALL (peer_node, rb, active_attr, new_attr){
             %(sub_query_create_all)s
         }
         WITH p2 as peer_node, rb, new_attr, active_attr
@@ -167,7 +165,7 @@ class AttributeRenameQuery(Query):
 
         if not (self.branch.is_default or self.branch.is_global):
             query = """
-            CALL {
+            CALL (peer_node, rb, active_attr) {
                 %(sub_query_update_all)s
             }
             WITH p2 as peer_node, rb, new_attr

infrahub/core/migrations/query/delete_element_in_schema.py

@@ -55,7 +55,6 @@ class DeleteElementInSchemaQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, direction: GraphRelDirection) -> str:
         subquery = [
-            f"WITH peer_node, {rel_name}, element_to_delete",
             f"WITH peer_node, {rel_name}, element_to_delete",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -67,28 +66,32 @@ class DeleteElementInSchemaQuery(Query):
         return "\n".join(subquery)
 
     @classmethod
-    def _render_sub_query_out(cls) -> str:
+    def _render_sub_query_out(cls) -> tuple[str, str]:
+        rel_name = "rel_outband"
+        sub_query_out_args = f"peer_node, {rel_name}, element_to_delete"
         sub_queries_out = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, direction=GraphRelDirection.OUTBOUND
+                rel_name=rel_name, rel_type=rel_type, direction=GraphRelDirection.OUTBOUND
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
             if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
-        return sub_query_out
+        return sub_query_out, sub_query_out_args
 
     @classmethod
-    def _render_sub_query_in(cls) -> str:
+    def _render_sub_query_in(cls) -> tuple[str, str]:
+        rel_name = "rel_inband"
+        sub_query_in_args = f"peer_node, {rel_name}, element_to_delete"
         sub_queries_in = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, direction=GraphRelDirection.INBOUND
+                rel_name=rel_name, rel_type=rel_type, direction=GraphRelDirection.INBOUND
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
             if rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
-        return sub_query_in
+        return sub_query_in, sub_query_in_args
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
@@ -108,8 +111,8 @@ class DeleteElementInSchemaQuery(Query):
             "from": self.at.to_string(),
         }
 
-        sub_query_out = self._render_sub_query_out()
-        sub_query_in = self._render_sub_query_in()
+        sub_query_out, sub_query_out_args = self._render_sub_query_out()
+        sub_query_in, sub_query_in_args = self._render_sub_query_in()
 
         self.add_to_query(self.render_match())
         self.add_to_query(self.render_where())
@@ -138,7 +141,7 @@ class DeleteElementInSchemaQuery(Query):
         }
         WITH n1 as element_to_delete, rel_outband1 as rel_outband, p1 as peer_node
         WHERE rel_outband.status = "active"
-        CALL {
+        CALL (%(sub_query_out_args)s) {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, element_to_delete
@@ -157,7 +160,7 @@ class DeleteElementInSchemaQuery(Query):
         }
         WITH n1 as element_to_delete, rel_inband1 as rel_inband, p1 as peer_node
         WHERE rel_inband.status = "active"
-        CALL {
+        CALL (%(sub_query_in_args)s) {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, element_to_delete
@@ -169,5 +172,7 @@ class DeleteElementInSchemaQuery(Query):
             "branch_filter": branch_filter,
             "sub_query_out": sub_query_out,
             "sub_query_in": sub_query_in,
+            "sub_query_out_args": sub_query_out_args,
+            "sub_query_in_args": sub_query_in_args,
         }
         self.add_to_query(query)

infrahub/core/migrations/query/node_duplicate.py

@@ -47,7 +47,6 @@ class NodeDuplicateQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, rel_dir: GraphRelDirection) -> str:
         subquery = [
-            f"WITH peer_node, {rel_name}, active_node, new_node",
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -81,28 +80,28 @@ class NodeDuplicateQuery(Query):
         return "\n".join(subquery)
 
     @classmethod
-    def _render_sub_query_out(cls) -> str:
+    def _render_sub_query_out(cls) -> tuple[str, str]:
+        rel_name = "rel_outband"
+        sub_query_out_args = f"peer_node, {rel_name}, active_node, new_node"
         sub_queries_out = [
-            cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, rel_dir=GraphRelDirection.OUTBOUND
-            )
+            cls._render_sub_query_per_rel_type(rel_name=rel_name, rel_type=rel_type, rel_dir=GraphRelDirection.OUTBOUND)
             for rel_type, field_info in GraphNodeRelationships.model_fields.items()
             if field_info.default.direction in (GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
-        return sub_query_out
+        return sub_query_out, sub_query_out_args
 
     @classmethod
-    def _render_sub_query_in(cls) -> str:
+    def _render_sub_query_in(cls) -> tuple[str, str]:
+        rel_name = "rel_inband"
+        sub_query_in_args = f"peer_node, {rel_name}, active_node, new_node"
         sub_queries_in = [
-            cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, rel_dir=GraphRelDirection.INBOUND
-            )
+            cls._render_sub_query_per_rel_type(rel_name=rel_name, rel_type=rel_type, rel_dir=GraphRelDirection.INBOUND)
             for rel_type, field_info in GraphNodeRelationships.model_fields.items()
             if field_info.default.direction in (GraphRelDirection.INBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
-        return sub_query_in
+        return sub_query_in, sub_query_in_args
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
@@ -126,8 +125,8 @@ class NodeDuplicateQuery(Query):
             "from": self.at.to_string(),
         }
 
-        sub_query_out = self._render_sub_query_out()
-        sub_query_in = self._render_sub_query_in()
+        sub_query_out, sub_query_out_args = self._render_sub_query_out()
+        sub_query_in, sub_query_in_args = self._render_sub_query_in()
 
         self.add_to_query(self.render_match())
 
@@ -155,7 +154,7 @@ class NodeDuplicateQuery(Query):
         }
         WITH n1 as active_node, rel_outband1 as rel_outband, p1 as peer_node, new_node
         WHERE rel_outband.status = "active" AND rel_outband.to IS NULL
-        CALL {
+        CALL (%(sub_query_out_args)s) {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, active_node, new_node
@@ -174,7 +173,7 @@ class NodeDuplicateQuery(Query):
         }
         WITH n1 as active_node, rel_inband1 as rel_inband, p1 as peer_node, new_node
         WHERE rel_inband.status = "active" AND rel_inband.to IS NULL
-        CALL {
+        CALL (%(sub_query_in_args)s) {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, active_node, new_node
@@ -188,5 +187,7 @@ class NodeDuplicateQuery(Query):
             "labels": ":".join(self.new_node.labels),
             "sub_query_out": sub_query_out,
             "sub_query_in": sub_query_in,
+            "sub_query_out_args": sub_query_out_args,
+            "sub_query_in_args": sub_query_in_args,
         }
         self.add_to_query(query)

infrahub/core/migrations/query/relationship_duplicate.py

@@ -47,7 +47,6 @@ class RelationshipDuplicateQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, direction: GraphRelDirection) -> str:
         subquery = [
-            f"WITH peer_node, {rel_name}, active_rel, new_rel",
             f"WITH peer_node, {rel_name}, active_rel, new_rel",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -61,28 +60,32 @@ class RelationshipDuplicateQuery(Query):
         return "\n".join(subquery)
 
     @classmethod
-    def _render_sub_query_out(cls) -> str:
+    def _render_sub_query_out(cls) -> tuple[str, str]:
+        rel_name = "rel_outband"
+        sub_query_out_args = f"peer_node, {rel_name}, active_rel, new_rel"
         sub_queries_out = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, direction=GraphRelDirection.OUTBOUND
+                rel_name=rel_name, rel_type=rel_type, direction=GraphRelDirection.OUTBOUND
             )
             for rel_type, rel_def in GraphRelationshipRelationships.model_fields.items()
             if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
-        return sub_query_out
+        return sub_query_out, sub_query_out_args
 
     @classmethod
-    def _render_sub_query_in(cls) -> str:
+    def _render_sub_query_in(cls) -> tuple[str, str]:
+        rel_name = "rel_inband"
+        sub_query_in_args = f"peer_node, {rel_name}, active_rel, new_rel"
         sub_queries_in = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, direction=GraphRelDirection.INBOUND
+                rel_name=rel_name, rel_type=rel_type, direction=GraphRelDirection.INBOUND
             )
             for rel_type, rel_def in GraphRelationshipRelationships.model_fields.items()
             if rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
-        return sub_query_in
+        return sub_query_in, sub_query_in_args
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
@@ -109,8 +112,8 @@ class RelationshipDuplicateQuery(Query):
             "from": self.at.to_string(),
         }
 
-        sub_query_out = self._render_sub_query_out()
-        sub_query_in = self._render_sub_query_in()
+        sub_query_out, sub_query_out_args = self._render_sub_query_out()
+        sub_query_in, sub_query_in_args = self._render_sub_query_in()
 
         self.add_to_query(self.render_match())
 
@@ -138,7 +141,7 @@ class RelationshipDuplicateQuery(Query):
         }
         WITH n1 as active_rel, rel_inband1 as rel_inband, p1 as peer_node, new_rel
         WHERE rel_inband.status = "active"
-        CALL {
+        CALL (%(sub_query_in_args)s) {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, active_rel, new_rel
@@ -157,7 +160,7 @@ class RelationshipDuplicateQuery(Query):
         }
         WITH n1 as active_rel, rel_outband1 as rel_outband, p1 as peer_node, new_rel
         WHERE rel_outband.status = "active"
-        CALL {
+        CALL (%(sub_query_out_args)s) {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, active_rel, new_rel
@@ -169,5 +172,7 @@ class RelationshipDuplicateQuery(Query):
             "branch_filter": branch_filter,
             "sub_query_out": sub_query_out,
             "sub_query_in": sub_query_in,
+            "sub_query_in_args": sub_query_in_args,
+            "sub_query_out_args": sub_query_out_args,
         }
         self.add_to_query(query)

infrahub/core/migrations/schema/node_attribute_remove.py

@@ -50,7 +50,6 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
 
         def render_sub_query_per_rel_type(rel_type: str, rel_def: FieldInfo) -> str:
             subquery = [
-                "WITH peer_node, rb, active_attr",
                 "WITH peer_node, rb, active_attr",
                 f'WHERE type(rb) = "{rel_type}"',
             ]
@@ -105,7 +104,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         }
         WITH a1 as active_attr, r1 as rb, p1 as peer_node
         WHERE rb.status = "active"
-        CALL {
+        CALL (peer_node, rb, active_attr) {
             %(sub_query_all)s
         }
         WITH p2 as peer_node, rb, active_attr

infrahub/core/migrations/schema/node_remove.py

@@ -21,7 +21,6 @@ class NodeRemoveMigrationBaseQuery(MigrationQuery):
         rel_def: FieldInfo,
     ) -> str:
         subquery = [
-            f"WITH peer_node, {rel_name}, active_node",
             f"WITH peer_node, {rel_name}, active_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -90,7 +89,7 @@ class NodeRemoveMigrationQueryIn(NodeRemoveMigrationBaseQuery):
     insert_return: bool = False
 
     def render_node_remove_query(self, branch_filter: str) -> str:
-        sub_query = self.render_sub_query_in()
+        sub_query, sub_query_args = self.render_sub_query_in()
         query = """
         // Process Inbound Relationship
         WITH active_node
@@ -104,27 +103,29 @@ class NodeRemoveMigrationQueryIn(NodeRemoveMigrationBaseQuery):
         }
         WITH n1 as active_node, rel_inband1 as rel_inband, p1 as peer_node
         WHERE rel_inband.status = "active"
-        CALL {
+        CALL (%(sub_query_args)s) {
             %(sub_query)s
         }
         WITH p2 as peer_node, rel_inband, active_node
         FOREACH (i in CASE WHEN rel_inband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_inband.to = $current_time
         )
-        """ % {"sub_query": sub_query, "branch_filter": branch_filter}
+        """ % {"sub_query": sub_query, "sub_query_args": sub_query_args, "branch_filter": branch_filter}
         return query
 
-    def render_sub_query_in(self) -> str:
+    def render_sub_query_in(self) -> tuple[str, str]:
+        rel_name = "rel_inband"
+        sub_query_in_args = f"peer_node, {rel_name}, active_node"
         sub_queries_in = [
             self.render_sub_query_per_rel_type(
-                rel_name="rel_inband",
+                rel_name=rel_name,
                 rel_type=rel_type,
                 rel_def=rel_def,
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
-        return sub_query_in
+        return sub_query_in, sub_query_in_args
 
     def get_nbr_migrations_executed(self) -> int:
         return 0
@@ -135,7 +136,7 @@ class NodeRemoveMigrationQueryOut(NodeRemoveMigrationBaseQuery):
     insert_return: bool = False
 
     def render_node_remove_query(self, branch_filter: str) -> str:
-        sub_query = self.render_sub_query_out()
+        sub_query, sub_query_args = self.render_sub_query_out()
         query = """
         // Process Outbound Relationship
         WITH active_node
@@ -149,27 +150,29 @@ class NodeRemoveMigrationQueryOut(NodeRemoveMigrationBaseQuery):
         }
         WITH n1 as active_node, rel_outband1 as rel_outband, p1 as peer_node
         WHERE rel_outband.status = "active"
-        CALL {
+        CALL (%(sub_query_args)s) {
             %(sub_query)s
         }
         FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_outband.to = $current_time
         )
-        """ % {"sub_query": sub_query, "branch_filter": branch_filter}
+        """ % {"sub_query": sub_query, "sub_query_args": sub_query_args, "branch_filter": branch_filter}
 
         return query
 
-    def render_sub_query_out(self) -> str:
+    def render_sub_query_out(self) -> tuple[str, str]:
+        rel_name = "rel_outband"
+        sub_query_out_args = f"peer_node, {rel_name}, active_node"
         sub_queries_out = [
             self.render_sub_query_per_rel_type(
-                rel_name="rel_outband",
+                rel_name=rel_name,
                 rel_type=rel_type,
                 rel_def=rel_def,
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
-        return sub_query_out
+        return sub_query_out, sub_query_out_args
 
     def get_nbr_migrations_executed(self) -> int:
         return self.num_of_results

infrahub/core/node/__init__.py

@@ -30,6 +30,7 @@ from infrahub.core.schema import (
     RelationshipSchema,
     TemplateSchema,
 )
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
 from infrahub.types import ATTRIBUTE_TYPES
@@ -254,6 +255,12 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         within the create code.
         """
 
+        number_pool_parameters: NumberPoolParameters | None = None
+        if attribute.schema.kind == "NumberPool" and isinstance(attribute.schema.parameters, NumberPoolParameters):
+            attribute.from_pool = {"id": attribute.schema.parameters.number_pool_id}
+            attribute.is_default = False
+            number_pool_parameters = attribute.schema.parameters
+
         if not attribute.from_pool:
             return
 
@@ -262,19 +269,25 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 db=db, id=attribute.from_pool["id"], kind=CoreNumberPool
             )
         except NodeNotFoundError:
-            errors.append(
-                ValidationError(
-                    {f"{attribute.name}.from_pool": f"The pool requested {attribute.from_pool} was not found."}
+            if number_pool_parameters:
+                number_pool = await self._create_number_pool(
+                    db=db, attribute=attribute, number_pool_parameters=number_pool_parameters
                 )
-            )
-            return
+
+            else:
+                errors.append(
+                    ValidationError(
+                        {f"{attribute.name}.from_pool": f"The pool requested {attribute.from_pool} was not found."}
+                    )
+                )
+                return
 
         if (
             number_pool.node.value in [self._schema.kind] + self._schema.inherit_from
             and number_pool.node_attribute.value == attribute.name
         ):
             try:
-                next_free = await number_pool.get_resource(db=db, branch=self._branch, node=self)
+                next_free = await number_pool.get_resource(db=db, branch=self._branch, node=self, attribute=attribute)
             except PoolExhaustedError:
                 errors.append(
                     ValidationError({f"{attribute.name}.from_pool": f"The pool {number_pool.node.value} is exhausted."})
@@ -292,6 +305,35 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 )
             )
 
+    async def _create_number_pool(
+        self, db: InfrahubDatabase, attribute: BaseAttribute, number_pool_parameters: NumberPoolParameters
+    ) -> CoreNumberPool:
+        schema = db.schema.get_node_schema(name="CoreNumberPool", duplicate=False)
+
+        pool_node = self._schema.kind
+        schema_attribute = self._schema.get_attribute(attribute.schema.name)
+        if schema_attribute.inherited:
+            for generic_name in self._schema.inherit_from:
+                generic_node = db.schema.get_generic_schema(name=generic_name, duplicate=False)
+                if attribute.schema.name in generic_node.attribute_names:
+                    pool_node = generic_node.kind
+                    break
+
+        number_pool = await Node.init(db=db, schema=schema, branch=self._branch)
+        await number_pool.new(
+            db=db,
+            id=number_pool_parameters.number_pool_id,
+            name=f"{pool_node}.{attribute.schema.name} [{number_pool_parameters.number_pool_id}]",
+            node=pool_node,
+            node_attribute=attribute.schema.name,
+            start_range=number_pool_parameters.start_range,
+            end_range=number_pool_parameters.end_range,
+        )
+        await number_pool.save(db=db)
+        # Do a lookup of the number pool to get the correct mapped type from the registry
+        # without this we don't get access to the .get_resource() method.
+        return await registry.manager.get_one_by_id_or_default_filter(db=db, id=number_pool.id, kind=CoreNumberPool)
+
     async def handle_object_template(self, fields: dict, db: InfrahubDatabase, errors: list) -> None:
         """Fill the `fields` parameters with values from an object template if one is in use."""
         object_template_field = fields.get(OBJECT_TEMPLATE_RELATIONSHIP_NAME)
@@ -376,6 +418,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                             self._computed_jinja2_attributes.append(mandatory_attr)
                             continue
 
+                        if mandatory_attribute.kind == "NumberPool":
+                            continue
+
                     errors.append(
                         ValidationError({mandatory_attr: f"{mandatory_attr} is mandatory for {self.get_kind()}"})
                     )
@@ -392,6 +437,21 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         # -------------------------------------------
         # Generate Attribute and Relationship and assign them
         # -------------------------------------------
+        errors.extend(await self._process_fields_relationships(fields=fields, db=db))
+        errors.extend(await self._process_fields_attributes(fields=fields, db=db))
+
+        if errors:
+            raise ValidationError(errors)
+
+        # Check if any post processor have been defined
+        # A processor can be used for example to assigne a default value
+        for name in self._attributes + self._relationships:
+            if hasattr(self, f"process_{name}"):
+                await getattr(self, f"process_{name}")(db=db)
+
+    async def _process_fields_relationships(self, fields: dict, db: InfrahubDatabase) -> list[ValidationError]:
+        errors: list[ValidationError] = []
+
         for rel_schema in self._schema.relationships:
             self._relationships.append(rel_schema.name)
 
@@ -413,6 +473,11 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             except ValidationError as exc:
                 errors.append(exc)
 
+        return errors
+
+    async def _process_fields_attributes(self, fields: dict, db: InfrahubDatabase) -> list[ValidationError]:
+        errors: list[ValidationError] = []
+
         for attr_schema in self._schema.attributes:
             self._attributes.append(attr_schema.name)
             if not self._existing and attr_schema.name in self._computed_jinja2_attributes:
@@ -441,14 +506,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             except ValidationError as exc:
                 errors.append(exc)
 
-        if errors:
-            raise ValidationError(errors)
-
-        # Check if any post processor have been defined
-        # A processor can be used for example to assigne a default value
-        for name in self._attributes + self._relationships:
-            if hasattr(self, f"process_{name}"):
-                await getattr(self, f"process_{name}")(db=db)
+        return errors
 
     async def _process_macros(self, db: InfrahubDatabase) -> None:
         schema_branch = db.schema.get_schema_branch(self._branch.name)

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -81,11 +81,15 @@ class CoreIPAddressPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int | None = None) -> IPAddressType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             ip_prefix = ipaddress.ip_network(resource.prefix.value)  # type: ignore[attr-defined]
             prefix_length = prefixlen or ip_prefix.prefixlen
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -88,11 +88,15 @@ class CoreIPPrefixPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int) -> IPNetworkType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             subnets = await get_subnets(
                 db=db,
                 ip_prefix=ipaddress.ip_network(resource.prefix.value),  # type: ignore[attr-defined]