infrahub-server 1.3.3__py3-none-any.whl → 1.3.4__py3-none-any.whl

infrahub/api/schema.py

@@ -151,9 +151,9 @@ def evaluate_candidate_schemas(
     branch_schema: SchemaBranch, schemas_to_evaluate: SchemasLoadAPI
 ) -> tuple[SchemaBranch, SchemaUpdateValidationResult]:
     candidate_schema = branch_schema.duplicate()
-    schema = _merge_candidate_schemas(schemas=schemas_to_evaluate.schemas)
-
     try:
+        schema = _merge_candidate_schemas(schemas=schemas_to_evaluate.schemas)
+
         candidate_schema.load_schema(schema=schema)
         candidate_schema.process()
 

infrahub/core/convert_object_type/conversion.py

@@ -9,6 +9,7 @@ from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
 from infrahub.core.node.create import create_node
 from infrahub.core.query.relationship import GetAllPeersIds
+from infrahub.core.query.resource_manager import PoolChangeReserved
 from infrahub.core.relationship import RelationshipManager
 from infrahub.core.schema import NodeSchema
 from infrahub.database import InfrahubDatabase
@@ -121,4 +122,13 @@ async def convert_object_type(
         for peer in peers.values():
             peer.validate_relationships()
 
+        # If the node had some value reserved in any Pools / Resource Manager, we need to change the identifier of the reservation(s)
+        query = await PoolChangeReserved.init(
+            db=dbt,
+            existing_identifier=node.get_id(),
+            new_identifier=node_created.get_id(),
+            branch=branch,
+        )
+        await query.execute(db=dbt)
+
         return node_created

infrahub/core/diff/enricher/hierarchy.py

@@ -7,6 +7,7 @@ from infrahub.core.query.node import NodeGetHierarchyQuery
 from infrahub.core.query.relationship import RelationshipGetPeerQuery, RelationshipPeerData
 from infrahub.core.schema import ProfileSchema, TemplateSchema
 from infrahub.database import InfrahubDatabase
+from infrahub.exceptions import SchemaNotFoundError
 from infrahub.log import get_logger
 
 from ..model.path import (
@@ -42,9 +43,12 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
         node_hierarchy_map: dict[str, list[NodeIdentifier]] = defaultdict(list)
 
         for node in enriched_diff_root.nodes:
-            schema_node = self.db.schema.get(
-                name=node.kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
-            )
+            try:
+                schema_node = self.db.schema.get(
+                    name=node.kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
+                )
+            except SchemaNotFoundError:
+                continue
 
             if isinstance(schema_node, ProfileSchema | TemplateSchema):
                 continue

infrahub/core/diff/query_parser.py

@@ -13,6 +13,7 @@ from infrahub.core.constants import (
 )
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.timestamp import Timestamp
+from infrahub.exceptions import SchemaNotFoundError
 
 from .model.field_specifiers_map import NodeFieldSpecifierMap
 from .model.path import (
@@ -566,9 +567,12 @@ class DiffQueryParser:
         if database_path.deepest_branch == self.diff_branch_name:
             branches_to_check.append(self.base_branch_name)
         for schema_branch_name in branches_to_check:
-            node_schema = self.schema_manager.get(
-                name=database_path.node_kind, branch=schema_branch_name, duplicate=False
-            )
+            try:
+                node_schema = self.schema_manager.get(
+                    name=database_path.node_kind, branch=schema_branch_name, duplicate=False
+                )
+            except SchemaNotFoundError:
+                continue
             relationship_schemas = node_schema.get_relationships_by_identifier(id=database_path.attribute_name)
             if len(relationship_schemas) == 1:
                 return relationship_schemas[0]

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 33
+GRAPH_VERSION = 34

infrahub/core/migrations/graph/__init__.py

@@ -35,6 +35,7 @@ from .m030_illegal_edges import Migration030
 from .m031_check_number_attributes import Migration031
 from .m032_cleanup_orphaned_branch_relationships import Migration032
 from .m033_deduplicate_relationship_vertices import Migration033
+from .m034_find_orphaned_schema_fields import Migration034
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -75,6 +76,7 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration031,
     Migration032,
     Migration033,
+    Migration034,
 ]
 
 

infrahub/core/migrations/graph/m034_find_orphaned_schema_fields.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.initialization import initialization
+from infrahub.core.manager import NodeManager
+from infrahub.core.migrations.shared import ArbitraryMigration, MigrationResult
+from infrahub.core.timestamp import Timestamp
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class FindOrphanedSchemaFieldsQuery(Query):
+    name = "find_orphaned_schema_fields"
+    type = QueryType.WRITE
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+// ------------
+// Find orphaned SchemaRelationship and SchemaAttribute vertices
+// ------------
+MATCH (schema_field:SchemaRelationship|SchemaAttribute)-[e:IS_RELATED]-(rel:Relationship)
+WHERE rel.name IN ["schema__node__relationships", "schema__node__attributes"]
+AND e.status = "deleted" OR e.to IS NOT NULL
+WITH schema_field, e.branch AS branch, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+CALL (schema_field, branch) {
+    OPTIONAL MATCH (schema_field)-[is_part_of:IS_PART_OF {branch: branch}]->(:Root)
+    WHERE is_part_of.status = "deleted" OR is_part_of.to IS NOT NULL
+    RETURN is_part_of IS NOT NULL AS is_deleted
+}
+WITH schema_field, branch, delete_time
+WHERE is_deleted = FALSE
+        """
+        self.add_to_query(query)
+        self.return_labels = ["schema_field.uuid AS schema_field_uuid", "branch", "delete_time"]
+
+
+class Migration034(ArbitraryMigration):
+    """
+    Finds active SchemaRelationship and SchemaAttribute vertices with deleted relationships to SchemaNodes or
+    SchemaGenerics and deletes them on the same branch at the same time
+    """
+
+    name: str = "034_find_orphaned_schema_fields"
+    minimum_version: int = 33
+    queries: Sequence[type[Query]] = [FindOrphanedSchemaFieldsQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        try:
+            initialize_lock()
+            await initialization(db=db)
+            query = await FindOrphanedSchemaFieldsQuery.init(db=db)
+            await query.execute(db=db)
+            schema_field_uuids_by_branch: dict[str, dict[str, str]] = defaultdict(dict)
+            for result in query.get_results():
+                schema_field_uuid = result.get_as_type("schema_field_uuid", return_type=str)
+                branch = result.get_as_type("branch", return_type=str)
+                delete_time = result.get_as_type("delete_time", return_type=str)
+                schema_field_uuids_by_branch[branch][schema_field_uuid] = delete_time
+
+            for branch, schema_rel_details in schema_field_uuids_by_branch.items():
+                node_map = await NodeManager.get_many(db=db, branch=branch, ids=list(schema_rel_details.keys()))
+                for schema_field_uuid, orphan_schema_rel_node in node_map.items():
+                    delete_time = Timestamp(schema_rel_details[schema_field_uuid])
+                    await orphan_schema_rel_node.delete(db=db, at=delete_time)
+        except Exception as exc:
+            log.exception("Error during orphaned schema field cleanup")
+            return MigrationResult(errors=[str(exc)])
+
+        return MigrationResult()

infrahub/core/migrations/schema/node_attribute_add.py

@@ -1,10 +1,22 @@
 from __future__ import annotations
 
-from typing import Any, Sequence
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core import registry
+from infrahub.core.node import Node
+from infrahub.exceptions import PoolExhaustedError
+from infrahub.tasks.registry import update_branch_registry
 
 from ..query import AttributeMigrationQuery
 from ..query.attribute_add import AttributeAddQuery
-from ..shared import AttributeSchemaMigration
+from ..shared import AttributeSchemaMigration, MigrationResult
+
+if TYPE_CHECKING:
+    from infrahub.core.node.resource_manager.number_pool import CoreNumberPool
+    from infrahub.database import InfrahubDatabase
+
+    from ...branch import Branch
+    from ...timestamp import Timestamp
 
 
 class NodeAttributeAddMigrationQuery01(AttributeMigrationQuery, AttributeAddQuery):
@@ -29,3 +41,44 @@ class NodeAttributeAddMigrationQuery01(AttributeMigrationQuery, AttributeAddQuer
 class NodeAttributeAddMigration(AttributeSchemaMigration):
     name: str = "node.attribute.add"
     queries: Sequence[type[AttributeMigrationQuery]] = [NodeAttributeAddMigrationQuery01]  # type: ignore[assignment]
+
+    async def execute_post_queries(
+        self,
+        db: InfrahubDatabase,
+        result: MigrationResult,
+        branch: Branch,
+        at: Timestamp,  # noqa: ARG002
+    ) -> MigrationResult:
+        if self.new_attribute_schema.kind != "NumberPool":
+            return result
+
+        number_pool: CoreNumberPool = await Node.fetch_or_create_number_pool(  # type: ignore[assignment]
+            db=db, branch=branch, schema_node=self.new_schema, schema_attribute=self.new_attribute_schema
+        )
+
+        await update_branch_registry(db=db, branch=branch)
+
+        nodes: list[Node] = await registry.manager.query(
+            db=db, branch=branch, schema=self.new_schema, fields={"id": True, self.new_attribute_schema.name: True}
+        )
+
+        try:
+            numbers = await number_pool.get_next_many(
+                db=db,
+                branch=branch,
+                quantity=len(nodes),
+                attribute=self.new_attribute_schema,
+            )
+        except PoolExhaustedError as exc:
+            result.errors.append(str(exc))
+            return result
+
+        for node, number in zip(nodes, numbers, strict=True):
+            await number_pool.reserve(db=db, number=number, identifier=node.get_id())
+            attr = getattr(node, self.new_attribute_schema.name)
+            attr.value = number
+            attr.source = number_pool.id
+
+            await node.save(db=db, fields=[self.new_attribute_schema.name])
+
+        return result

infrahub/core/migrations/shared.py

@@ -16,13 +16,13 @@ from infrahub.core.schema import (
     SchemaRoot,
     internal_schema,
 )
+from infrahub.core.timestamp import Timestamp
 
 from .query import MigrationQuery  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.schema.schema_branch import SchemaBranch
-    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -47,18 +47,46 @@ class SchemaMigration(BaseModel):
     previous_node_schema: NodeSchema | GenericSchema | None = None
     schema_path: SchemaPath
 
+    async def execute_pre_queries(
+        self,
+        db: InfrahubDatabase,  # noqa: ARG002
+        result: MigrationResult,
+        branch: Branch,  # noqa: ARG002
+        at: Timestamp,  # noqa: ARG002
+    ) -> MigrationResult:
+        return result
+
+    async def execute_post_queries(
+        self,
+        db: InfrahubDatabase,  # noqa: ARG002
+        result: MigrationResult,
+        branch: Branch,  # noqa: ARG002
+        at: Timestamp,  # noqa: ARG002
+    ) -> MigrationResult:
+        return result
+
+    async def execute_queries(
+        self, db: InfrahubDatabase, result: MigrationResult, branch: Branch, at: Timestamp
+    ) -> MigrationResult:
+        for migration_query in self.queries:
+            try:
+                query = await migration_query.init(db=db, branch=branch, at=at, migration=self)
+                await query.execute(db=db)
+                result.nbr_migrations_executed += query.get_nbr_migrations_executed()
+            except Exception as exc:
+                result.errors.append(str(exc))
+                return result
+
+        return result
+
     async def execute(self, db: InfrahubDatabase, branch: Branch, at: Timestamp | str | None = None) -> MigrationResult:
         async with db.start_transaction() as ts:
             result = MigrationResult()
+            at = Timestamp(at)
 
-            for migration_query in self.queries:
-                try:
-                    query = await migration_query.init(db=ts, branch=branch, at=at, migration=self)
-                    await query.execute(db=ts)
-                    result.nbr_migrations_executed += query.get_nbr_migrations_executed()
-                except Exception as exc:
-                    result.errors.append(str(exc))
-                    return result
+            await self.execute_pre_queries(db=ts, result=result, branch=branch, at=at)
+            await self.execute_queries(db=ts, result=result, branch=branch, at=at)
+            await self.execute_post_queries(db=ts, result=result, branch=branch, at=at)
 
         return result
 

infrahub/core/node/__init__.py

@@ -26,6 +26,7 @@ from infrahub.core.protocols import CoreNumberPool, CoreObjectTemplate
 from infrahub.core.query.node import NodeCheckIDQuery, NodeCreateAllQuery, NodeDeleteQuery, NodeGetListQuery
 from infrahub.core.schema import (
     AttributeSchema,
+    GenericSchema,
     NodeSchema,
     NonGenericSchemaTypes,
     ProfileSchema,
@@ -263,11 +264,9 @@ 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
@@ -277,9 +276,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 db=db, id=attribute.from_pool["id"], kind=CoreNumberPool
             )
         except NodeNotFoundError:
-            if number_pool_parameters:
-                number_pool = await self._fetch_or_create_number_pool(
-                    db=db, attribute=attribute, number_pool_parameters=number_pool_parameters
+            if attribute.schema.kind == "NumberPool" and isinstance(attribute.schema.parameters, NumberPoolParameters):
+                number_pool = await self.fetch_or_create_number_pool(
+                    db=db, schema_node=self._schema, schema_attribute=attribute.schema, branch=self._branch
                 )
 
             else:
@@ -295,7 +294,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             and number_pool.node_attribute.value == attribute.name
         ):
             try:
-                next_free = await number_pool.get_resource(db=db, branch=self._branch, node=self, attribute=attribute)
+                next_free = await number_pool.get_resource(
+                    db=db, branch=self._branch, node=self, attribute=attribute.schema
+                )
             except PoolExhaustedError:
                 errors.append(
                     ValidationError({f"{attribute.name}.from_pool": f"The pool {number_pool.node.value} is exhausted."})
@@ -313,10 +314,28 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 )
             )
 
-    async def _fetch_or_create_number_pool(
-        self, db: InfrahubDatabase, attribute: BaseAttribute, number_pool_parameters: NumberPoolParameters
+    @staticmethod
+    async def fetch_or_create_number_pool(
+        db: InfrahubDatabase,
+        schema_node: NodeSchema | GenericSchema,
+        schema_attribute: AttributeSchema,
+        branch: Branch | None = None,
     ) -> CoreNumberPool:
+        """Fetch or create a number pool based on the schema attribute parameters.
+
+        Warning, ideally this method should be outside of the Node class, but it is itself using the Node class to create the pool node.
+        """
+
+        if (
+            schema_attribute.kind != "NumberPool"
+            or not schema_attribute.parameters
+            or not isinstance(schema_attribute.parameters, NumberPoolParameters)
+        ):
+            raise ValueError("Attribute is not of type NumberPool")
+
         number_pool_from_db: CoreNumberPool | None = None
+        number_pool_parameters: NumberPoolParameters = schema_attribute.parameters
+
         lock_definition = NumberPoolLockDefinition(pool_id=str(number_pool_parameters.number_pool_id))
         async with lock.registry.get(
             name=lock_definition.lock_name, namespace=lock_definition.namespace_name, local=False
@@ -325,37 +344,37 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 number_pool_from_db = await registry.manager.get_one_by_id_or_default_filter(
                     db=db, id=str(number_pool_parameters.number_pool_id), kind=CoreNumberPool
                 )
+                return number_pool_from_db  # type: ignore[return-value]
+
             except NodeNotFoundError:
                 schema = db.schema.get_node_schema(name="CoreNumberPool", duplicate=False)
 
-                pool_node = self._schema.kind
-                schema_attribute = self._schema.get_attribute(attribute.schema.name)
+                pool_node = schema_node.kind
                 if schema_attribute.inherited:
-                    for generic_name in self._schema.inherit_from:
+                    for generic_name in schema_node.inherit_from:
                         generic_node = db.schema.get_generic_schema(name=generic_name, duplicate=False)
-                        if attribute.schema.name in generic_node.attribute_names:
+                        if schema_attribute.name in generic_node.attribute_names:
                             pool_node = generic_node.kind
                             break
 
-                number_pool = await Node.init(db=db, schema=schema, branch=self._branch)
+                number_pool = await Node.init(db=db, schema=schema, branch=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}]",
+                    name=f"{pool_node}.{schema_attribute.name} [{number_pool_parameters.number_pool_id}]",
                     node=pool_node,
-                    node_attribute=attribute.schema.name,
+                    node_attribute=schema_attribute.name,
                     start_range=number_pool_parameters.start_range,
                     end_range=number_pool_parameters.end_range,
                     pool_type=NumberPoolType.SCHEMA.value,
                 )
                 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.
-        created_pool: CoreNumberPool = number_pool_from_db or await registry.manager.get_one_by_id_or_default_filter(
-            db=db, id=number_pool.id, kind=CoreNumberPool
-        )
-        return created_pool
+                # 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."""
@@ -819,6 +838,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         query = await NodeDeleteQuery.init(db=db, node=self, at=delete_at)
         await query.execute(db=db)
+
         self._node_changelog = node_changelog
 
     async def to_graphql(

infrahub/core/node/resource_manager/number_pool.py

@@ -10,17 +10,15 @@ 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.core.schema import AttributeSchema
     from infrahub.core.timestamp import Timestamp
     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.
-        """
+        """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]
@@ -35,18 +33,42 @@ class CoreNumberPool(Node):
         res = len(attribute.parameters.get_excluded_single_values()) + sum_excluded_values
         return res
 
+    async def get_used(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+    ) -> list[int]:
+        """Returns a list of used numbers in the pool."""
+
+        query = await NumberPoolGetUsed.init(db=db, branch=branch, pool=self, branch_agnostic=True)
+        await query.execute(db=db)
+        used = [result.value for result in query.iter_results()]
+        return [item for item in used if item is not None]
+
+    async def reserve(self, db: InfrahubDatabase, number: int, identifier: str, at: Timestamp | None = None) -> None:
+        """Reserve a number in the pool for a specific identifier."""
+
+        query = await NumberPoolSetReserved.init(
+            db=db, pool_id=self.get_id(), identifier=identifier, reserved=number, at=at
+        )
+        await query.execute(db=db)
+
     async def get_resource(
         self,
         db: InfrahubDatabase,
         branch: Branch,
         node: Node,
-        attribute: BaseAttribute,
+        attribute: AttributeSchema,
         identifier: str | None = None,
         at: Timestamp | None = None,
     ) -> int:
+        # NOTE: ideally we should use the HFID as the identifier (if available)
+        # one of the challenge with using the HFID is that it might change over time
+        # so we need to ensure that the identifier is stable, or we need to handle the case where the identifier changes
         identifier = identifier or node.get_id()
+
         # Check if there is already a resource allocated with this identifier
-        # if not, pull all existing prefixes and allocated the next available
+        # if not, pull all existing number and allocate the next available
         # TODO add support for branch, if the node is reserved with this id in another branch we should return an error
         query_get = await NumberPoolGetReserved.init(db=db, branch=branch, pool_id=self.id, identifier=identifier)
         await query_get.execute(db=db)
@@ -56,35 +78,51 @@ class CoreNumberPool(Node):
 
         # If we have not returned a value we need to find one if avaiable
         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, at=at
-        )
-        await query_set.execute(db=db)
+        await self.reserve(db=db, number=number, identifier=identifier, at=at)
         return number
 
-    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
+    async def get_next(self, db: InfrahubDatabase, branch: Branch, attribute: AttributeSchema) -> int:
+        taken = await self.get_used(db=db, branch=branch)
+
         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,
+            parameters=attribute.parameters if isinstance(attribute.parameters, NumberAttributeParameters) else None,
         )
         if next_number is None:
             raise PoolExhaustedError("There are no more values available in this pool.")
 
         return next_number
 
+    async def get_next_many(
+        self, db: InfrahubDatabase, quantity: int, branch: Branch, attribute: AttributeSchema
+    ) -> list[int]:
+        taken = await self.get_used(db=db, branch=branch)
+
+        allocated: list[int] = []
+
+        for _ in range(quantity):
+            next_number = find_next_free(
+                start=self.start_range.value,  # type: ignore[attr-defined]
+                end=self.end_range.value,  # type: ignore[attr-defined]
+                taken=list(set(taken) | set(allocated)),
+                parameters=attribute.parameters
+                if isinstance(attribute.parameters, NumberAttributeParameters)
+                else None,
+            )
+            if next_number is None:
+                raise PoolExhaustedError(
+                    f"There are no more values available in this pool, couldn't allocate {quantity} values, only {len(allocated)} available."
+                )
+
+            allocated.append(next_number)
+
+        return allocated
+
 
-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)
+def find_next_free(start: int, end: int, taken: list[int], parameters: NumberAttributeParameters | None) -> int | None:
+    used_set = set(taken)
 
     for num in range(start, end + 1):
         if num not in used_set: