infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/diff/repository/deserializer.py

@@ -18,10 +18,12 @@ from ..model.path import (
     EnrichedDiffSingleRelationship,
     deserialize_tracking_id,
 )
+from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
 
 
 class EnrichedDiffDeserializer:
-    def __init__(self) -> None:
+    def __init__(self, parent_adder: DiffParentNodeAdder) -> None:
+        self.parent_adder = parent_adder
         self._diff_root_map: dict[str, EnrichedDiffRoot] = {}
         self._diff_node_map: dict[tuple[str, str], EnrichedDiffNode] = {}
         self._diff_node_attr_map: dict[tuple[str, str, str], EnrichedDiffAttribute] = {}
@@ -127,6 +129,7 @@ class EnrichedDiffDeserializer:
 
     def _deserialize_parents(self) -> None:
         for enriched_root, node_path_tuples in self._parents_path_map.items():
+            self.parent_adder.initialize(enriched_diff_root=enriched_root)
             for node_uuid, parents_path in node_path_tuples:
                 # Remove the node itself from the path
                 parents_path_slice = parents_path.nodes[1:]
@@ -134,7 +137,7 @@ class EnrichedDiffDeserializer:
                 # TODO Ensure the list is even
                 current_node_uuid = node_uuid
                 for rel, parent in zip(parents_path_slice[::2], parents_path_slice[1::2], strict=False):
-                    enriched_root.add_parent(
+                    parent_request = ParentNodeAddRequest(
                         node_id=current_node_uuid,
                         parent_id=parent.get("uuid"),
                         parent_kind=parent.get("kind"),
@@ -144,6 +147,7 @@ class EnrichedDiffDeserializer:
                         parent_rel_cardinality=RelationshipCardinality(rel.get("cardinality")),
                         parent_rel_label=rel.get("label"),
                     )
+                    self.parent_adder.add_parent(parent_request=parent_request)
                     current_node_uuid = parent.get("uuid")
 
     @classmethod
@@ -164,6 +168,7 @@ class EnrichedDiffDeserializer:
     def build_diff_root_metadata(cls, root_node: Neo4jNode) -> EnrichedDiffRootMetadata:
         from_time = Timestamp(str(root_node.get("from_time")))
         to_time = Timestamp(str(root_node.get("to_time")))
+        partner_uuid = cls._get_str_or_none_property_value(node=root_node, property_name="partner_uuid")
         tracking_id_str = str(root_node.get("tracking_id"))
         tracking_id = deserialize_tracking_id(tracking_id_str=tracking_id_str)
         return EnrichedDiffRootMetadata(
@@ -172,7 +177,7 @@ class EnrichedDiffDeserializer:
             from_time=from_time,
             to_time=to_time,
             uuid=str(root_node.get("uuid")),
-            partner_uuid=str(root_node.get("partner_uuid")),
+            partner_uuid=partner_uuid,
             tracking_id=tracking_id,
             num_added=int(root_node.get("num_added", 0)),
             num_updated=int(root_node.get("num_updated", 0)),

infrahub/core/diff/repository/repository.py

@@ -1,10 +1,15 @@
 from collections import defaultdict
 from typing import AsyncGenerator, Generator, Iterable
 
+from neo4j.exceptions import TransientError
+
 from infrahub import config
 from infrahub.core import registry
 from infrahub.core.diff.query.field_summary import EnrichedDiffNodeFieldSummaryQuery
-from infrahub.core.diff.query.summary_counts_enricher import DiffSummaryCountsEnricherQuery
+from infrahub.core.diff.query.summary_counts_enricher import (
+    DiffFieldsSummaryCountsEnricherQuery,
+    DiffNodesSummaryCountsEnricherQuery,
+)
 from infrahub.core.query.diff import DiffCountChanges
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase, retry_db_transaction
@@ -14,6 +19,7 @@ from infrahub.log import get_logger
 from ..model.path import (
     ConflictSelection,
     EnrichedDiffConflict,
+    EnrichedDiffNode,
     EnrichedDiffRoot,
     EnrichedDiffRootMetadata,
     EnrichedDiffs,
@@ -42,11 +48,10 @@ log = get_logger()
 
 
 class DiffRepository:
-    MAX_SAVE_BATCH_SIZE: int = 100
-
-    def __init__(self, db: InfrahubDatabase, deserializer: EnrichedDiffDeserializer):
+    def __init__(self, db: InfrahubDatabase, deserializer: EnrichedDiffDeserializer, max_save_batch_size: int = 1000):
         self.db = db
         self.deserializer = deserializer
+        self.max_save_batch_size = max_save_batch_size
 
     async def _run_get_diff_query(
         self,
@@ -154,18 +159,23 @@ class DiffRepository:
             diff_branch_names=[base_branch_name],
             max_depth=max_depth,
             batch_size_limit=batch_size_limit,
-            diff_ids=[d.partner_uuid for d in diffs_by_uuid.values()],
+            diff_ids=[d.partner_uuid for d in diffs_by_uuid.values() if d.partner_uuid],
         )
         diffs_by_uuid.update({bbr.uuid: bbr for bbr in base_branch_roots})
-        return [
-            EnrichedDiffs(
-                base_branch_name=base_branch_name,
-                diff_branch_name=diff_branch_name,
-                base_branch_diff=diffs_by_uuid[dbr.partner_uuid],
-                diff_branch_diff=dbr,
+        diff_pairs = []
+        for dbr in diff_branch_roots:
+            if dbr.partner_uuid is None:
+                continue
+            base_branch_diff = diffs_by_uuid[dbr.partner_uuid]
+            diff_pairs.append(
+                EnrichedDiffs(
+                    base_branch_name=base_branch_name,
+                    diff_branch_name=diff_branch_name,
+                    base_branch_diff=base_branch_diff,
+                    diff_branch_diff=dbr,
+                )
             )
-            for dbr in diff_branch_roots
-        ]
+        return diff_pairs
 
     async def hydrate_diff_pair(
         self,
@@ -225,43 +235,111 @@ class DiffRepository:
     ) -> Generator[list[EnrichedNodeCreateRequest], None, None]:
         node_requests = []
         for diff_root in (enriched_diffs.base_branch_diff, enriched_diffs.diff_branch_diff):
+            size_count = 0
             for node in diff_root.nodes:
-                node_requests.append(EnrichedNodeCreateRequest(node=node, root_uuid=diff_root.uuid))
-                if len(node_requests) == self.MAX_SAVE_BATCH_SIZE:
+                node_size_count = node.num_properties
+                if size_count + node_size_count < self.max_save_batch_size:
+                    node_requests.append(EnrichedNodeCreateRequest(node=node, root_uuid=diff_root.uuid))
+                    size_count += node_size_count
+                else:
+                    log.info(f"Num nodes in batch: {len(node_requests)}, num properties in batch: {size_count}")
                     yield node_requests
-                    node_requests = []
+                    size_count = node_size_count
+                    node_requests = [EnrichedNodeCreateRequest(node=node, root_uuid=diff_root.uuid)]
         if node_requests:
+            log.info(f"Num nodes in batch: {len(node_requests)}, num properties in batch: {size_count}")
             yield node_requests
 
-    @retry_db_transaction(name="enriched_diff_save")
-    async def save(self, enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata, do_summary_counts: bool = True) -> None:
+    @retry_db_transaction(name="enriched_diff_metadata_save")
+    async def _save_root_metadata(self, enriched_diffs: EnrichedDiffsMetadata) -> None:
         log.info("Updating diff metadata...")
         root_query = await EnrichedDiffRootsUpsertQuery.init(db=self.db, enriched_diffs=enriched_diffs)
         await root_query.execute(db=self.db)
         log.info("Diff metadata updated.")
+
+    async def _save_node_batch(self, node_create_batch: list[EnrichedNodeCreateRequest]) -> None:
+        node_query = await EnrichedNodeBatchCreateQuery.init(db=self.db, node_create_batch=node_create_batch)
+        try:
+            await node_query.execute(db=self.db)
+        except TransientError as exc:
+            if not exc.code or "OutOfMemoryError".lower() not in str(exc.code).lower():
+                raise
+            log.exception("Database memory error during save. Trying smaller transactions")
+            for node_request in node_create_batch:
+                log.info(
+                    f"Updating node {node_request.node.uuid}, num_properties={node_request.node.num_properties}..."
+                )
+                single_node_query = await EnrichedNodeBatchCreateQuery.init(
+                    db=self.db, node_create_batch=[node_request]
+                )
+                await single_node_query.execute(db=self.db)
+
+    @retry_db_transaction(name="enriched_diff_hierarchy_update")
+    async def _run_hierarchy_links_update_query(self, diff_root_uuid: str, diff_nodes: list[EnrichedDiffNode]) -> None:
+        log.info(f"Updating diff hierarchy links, num_nodes={len(diff_nodes)}")
+        link_query = await EnrichedNodesLinkQuery.init(db=self.db, diff_root_uuid=diff_root_uuid, diff_nodes=diff_nodes)
+        await link_query.execute(db=self.db)
+
+    async def _update_hierarchy_links(self, enriched_diffs: EnrichedDiffs) -> None:
+        for diff_root in (enriched_diffs.base_branch_diff, enriched_diffs.diff_branch_diff):
+            nodes_to_update = []
+            for node in diff_root.nodes:
+                if any(r.nodes for r in node.relationships):
+                    nodes_to_update.append(node)
+                if len(nodes_to_update) >= config.SETTINGS.database.query_size_limit:
+                    await self._run_hierarchy_links_update_query(
+                        diff_root_uuid=diff_root.uuid, diff_nodes=nodes_to_update
+                    )
+                    nodes_to_update = []
+            if nodes_to_update:
+                await self._run_hierarchy_links_update_query(diff_root_uuid=diff_root.uuid, diff_nodes=nodes_to_update)
+
+    async def _update_summary_counts(self, diff_root: EnrichedDiffRoot) -> None:
+        max_nodes_limit = config.SETTINGS.database.query_size_limit
+        num_nodes = len(diff_root.nodes)
+        if diff_root.exists_on_database and num_nodes < max_nodes_limit:
+            await self.add_summary_counts(
+                diff_branch_name=diff_root.diff_branch_name,
+                diff_id=diff_root.uuid,
+                node_uuids=None,
+            )
+            return
+        node_uuids: list[str] = []
+        for diff_node in diff_root.nodes:
+            node_uuids.append(diff_node.uuid)
+            if len(node_uuids) >= max_nodes_limit:
+                await self.add_summary_counts(
+                    diff_branch_name=diff_root.diff_branch_name,
+                    diff_id=diff_root.uuid,
+                    node_uuids=node_uuids,
+                )
+                node_uuids = []
+        if node_uuids:
+            await self.add_summary_counts(
+                diff_branch_name=diff_root.diff_branch_name,
+                diff_id=diff_root.uuid,
+                node_uuids=node_uuids,
+            )
+
+    async def save(self, enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata, do_summary_counts: bool = True) -> None:
+        # metadata-only update
         if not isinstance(enriched_diffs, EnrichedDiffs):
+            await self._save_root_metadata(enriched_diffs=enriched_diffs)
             return
-        num_nodes = len(enriched_diffs.base_branch_diff.nodes) + len(enriched_diffs.diff_branch_diff.nodes)
-        log.info(f"Saving diff (num_nodes={num_nodes})...")
+
+        count_nodes_remaining = len(enriched_diffs.base_branch_diff.nodes) + len(enriched_diffs.diff_branch_diff.nodes)
+        log.info(f"Saving diff (num_nodes={count_nodes_remaining})...")
         for batch_num, node_create_batch in enumerate(
             self._get_node_create_request_batch(enriched_diffs=enriched_diffs)
         ):
             log.info(f"Saving node batch #{batch_num}...")
-            node_query = await EnrichedNodeBatchCreateQuery.init(db=self.db, node_create_batch=node_create_batch)
-            await node_query.execute(db=self.db)
-            log.info(f"Batch #{batch_num} saved")
-        link_query = await EnrichedNodesLinkQuery.init(db=self.db, enriched_diffs=enriched_diffs)
-        await link_query.execute(db=self.db)
-        log.info("Diff saved.")
+            await self._save_node_batch(node_create_batch=node_create_batch)
+            count_nodes_remaining -= len(node_create_batch)
+            log.info(f"Batch saved. {count_nodes_remaining=}")
+        await self._update_hierarchy_links(enriched_diffs=enriched_diffs)
         if do_summary_counts:
-            node_uuids: list[str] | None = None
-            if enriched_diffs.diff_branch_diff.exists_on_database:
-                node_uuids = list(enriched_diffs.branch_node_uuids)
-            await self.add_summary_counts(
-                diff_branch_name=enriched_diffs.diff_branch_name,
-                diff_id=enriched_diffs.diff_branch_diff.uuid,
-                node_uuids=node_uuids,
-            )
+            await self._update_summary_counts(diff_root=enriched_diffs.diff_branch_diff)
+        await self._save_root_metadata(enriched_diffs=enriched_diffs)
 
     async def summary(
         self,
@@ -325,7 +403,7 @@ class DiffRepository:
         roots_by_id = {root.uuid: root for root in empty_roots}
         pairs: list[EnrichedDiffsMetadata] = []
         for branch_root in empty_roots:
-            if branch_root.base_branch_name == branch_root.diff_branch_name:
+            if branch_root.base_branch_name == branch_root.diff_branch_name or branch_root.partner_uuid is None:
                 continue
             base_root = roots_by_id[branch_root.partner_uuid]
             pairs.append(
@@ -446,8 +524,48 @@ class DiffRepository:
         diff_id: str | None = None,
         node_uuids: list[str] | None = None,
     ) -> None:
-        log.info("Updating summary counts...")
-        query = await DiffSummaryCountsEnricherQuery.init(
+        await self._add_field_summary_counts(
+            diff_branch_name=diff_branch_name,
+            tracking_id=tracking_id,
+            diff_id=diff_id,
+            node_uuids=node_uuids,
+        )
+        await self._add_node_summary_counts(
+            diff_branch_name=diff_branch_name,
+            tracking_id=tracking_id,
+            diff_id=diff_id,
+            node_uuids=node_uuids,
+        )
+
+    @retry_db_transaction(name="enriched_diff_field_summary_counts")
+    async def _add_field_summary_counts(
+        self,
+        diff_branch_name: str,
+        tracking_id: TrackingId | None = None,
+        diff_id: str | None = None,
+        node_uuids: list[str] | None = None,
+    ) -> None:
+        log.info("Updating field summary counts...")
+        query = await DiffFieldsSummaryCountsEnricherQuery.init(
+            db=self.db,
+            diff_branch_name=diff_branch_name,
+            tracking_id=tracking_id,
+            diff_id=diff_id,
+            node_uuids=node_uuids,
+        )
+        await query.execute(db=self.db)
+        log.info("Field summary counts updated.")
+
+    @retry_db_transaction(name="enriched_diff_node_summary_counts")
+    async def _add_node_summary_counts(
+        self,
+        diff_branch_name: str,
+        tracking_id: TrackingId | None = None,
+        diff_id: str | None = None,
+        node_uuids: list[str] | None = None,
+    ) -> None:
+        log.info("Updating node summary counts...")
+        query = await DiffNodesSummaryCountsEnricherQuery.init(
             db=self.db,
             diff_branch_name=diff_branch_name,
             tracking_id=tracking_id,
@@ -455,4 +573,4 @@ class DiffRepository:
             node_uuids=node_uuids,
         )
         await query.execute(db=self.db)
-        log.info("Summary counts updated...")
+        log.info("node summary counts updated.")

infrahub/core/diff/tasks.py

@@ -11,14 +11,14 @@ from infrahub.dependencies.registry import get_component_registry
 from infrahub.log import get_logger
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.catalogue import DIFF_REFRESH
-from infrahub.workflows.utils import add_branch_tag
+from infrahub.workflows.utils import add_tags
 
 log = get_logger()
 
 
 @flow(name="diff-update", flow_run_name="Update diff for branch {model.branch_name}")
 async def update_diff(model: RequestDiffUpdate, service: InfrahubServices) -> None:
-    await add_branch_tag(branch_name=model.branch_name)
+    await add_tags(branches=[model.branch_name])
 
     async with service.database.start_session() as db:
         component_registry = get_component_registry()
@@ -38,7 +38,7 @@ async def update_diff(model: RequestDiffUpdate, service: InfrahubServices) -> No
 
 @flow(name="diff-refresh", flow_run_name="Recreate diff for branch {branch_name}")
 async def refresh_diff(branch_name: str, diff_id: str, service: InfrahubServices) -> None:
-    await add_branch_tag(branch_name=branch_name)
+    await add_tags(branches=[branch_name])
 
     async with service.database.start_session() as db:
         component_registry = get_component_registry()
@@ -51,7 +51,7 @@ async def refresh_diff(branch_name: str, diff_id: str, service: InfrahubServices
 
 @flow(name="diff-refresh-all", flow_run_name="Recreate all diffs for branch {branch_name}")
 async def refresh_diff_all(branch_name: str, context: InfrahubContext, service: InfrahubServices) -> None:
-    await add_branch_tag(branch_name=branch_name)
+    await add_tags(branches=[branch_name])
 
     async with service.database.start_session() as db:
         component_registry = get_component_registry()

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 18
+GRAPH_VERSION = 22

infrahub/core/graph/index.py

@@ -12,6 +12,9 @@ node_indexes: list[IndexItem] = [
     IndexItem(name="attr_iphost_bin", label="AttributeIPHost", properties=["binary_address"], type=IndexType.RANGE),
     IndexItem(name="rel_uuid", label="Relationship", properties=["uuid"], type=IndexType.RANGE),
     IndexItem(name="rel_identifier", label="Relationship", properties=["name"], type=IndexType.RANGE),
+    # diff indices
+    IndexItem(name="diff_uuid", label="DiffRoot", properties=["uuid"], type=IndexType.TEXT),
+    IndexItem(name="diff_node_uuid", label="DiffNode", properties=["uuid"], type=IndexType.TEXT),
 ]
 
 rel_indexes: list[IndexItem] = [

infrahub/core/initialization.py

@@ -28,8 +28,7 @@ from infrahub.database import InfrahubDatabase
 from infrahub.exceptions import DatabaseError
 from infrahub.graphql.manager import GraphQLSchemaManager
 from infrahub.log import get_logger
-from infrahub.menu.menu import default_menu
-from infrahub.menu.utils import create_menu_children
+from infrahub.menu.utils import create_default_menu
 from infrahub.permissions import PermissionBackend
 from infrahub.storage import InfrahubObjectStorage
 
@@ -305,14 +304,6 @@ async def create_ipam_namespace(
     return obj
 
 
-async def create_default_menu(db: InfrahubDatabase) -> None:
-    for item in default_menu:
-        obj = await item.to_node(db=db)
-        await obj.save(db=db)
-        if item.children:
-            await create_menu_children(db=db, parent=obj, children=item.children)
-
-
 async def create_super_administrator_role(db: InfrahubDatabase) -> Node:
     permission = await Node.init(db=db, schema=InfrahubKind.GLOBALPERMISSION)
     await permission.new(

infrahub/core/ipam/constants.py

@@ -1,10 +1,9 @@
 import ipaddress
 from enum import Enum
-from typing import Union
 
-IPNetworkType = Union[ipaddress.IPv6Network, ipaddress.IPv4Network]
-IPAddressType = Union[ipaddress.IPv6Interface, ipaddress.IPv4Interface]
-AllIPTypes = Union[IPNetworkType, IPAddressType]
+IPNetworkType = ipaddress.IPv6Network | ipaddress.IPv4Network
+IPAddressType = ipaddress.IPv6Interface | ipaddress.IPv4Interface
+AllIPTypes = IPNetworkType | IPAddressType
 
 
 class PrefixMemberType(Enum):

infrahub/core/ipam/reconciler.py

@@ -1,5 +1,5 @@
 import ipaddress
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from infrahub.core.branch import Branch
 from infrahub.core.constants import InfrahubKind
@@ -20,8 +20,8 @@ class IPNodesToReconcile:
     def __init__(
         self,
         node_uuid: str,
-        current_parent_uuid: Optional[str],
-        calculated_parent_uuid: Optional[str],
+        current_parent_uuid: str | None,
+        calculated_parent_uuid: str | None,
         current_child_uuids: set[str],
         calculated_child_uuids: set[str],
         node_map: dict[str, Node],
@@ -46,13 +46,13 @@ class IPNodesToReconcile:
         return self.node_map[self.node_uuid]
 
     @property
-    def current_parent(self) -> Optional[Node]:
+    def current_parent(self) -> Node | None:
         if not self.current_parent_uuid:
             return None
         return self.node_map.get(self.current_parent_uuid)
 
     @property
-    def calculated_parent(self) -> Optional[Node]:
+    def calculated_parent(self) -> Node | None:
         if not self.calculated_parent_uuid:
             return None
         return self.node_map.get(self.calculated_parent_uuid)
@@ -68,7 +68,7 @@ class IPNodesToReconcile:
     def get_node_by_uuid(self, uuid: str) -> Node:
         return self.node_map[uuid]
 
-    async def _get_child_uuids(self, db: InfrahubDatabase, node: Optional[Node]) -> set[str]:
+    async def _get_child_uuids(self, db: InfrahubDatabase, node: Node | None) -> set[str]:
         if not node:
             return set()
         child_uuids = set()
@@ -83,17 +83,17 @@ class IpamReconciler:
     def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
         self.db = db
         self.branch = branch
-        self.at: Optional[Timestamp] = None
+        self.at: Timestamp | None = None
 
     @retry_db_transaction(name="ipam_reconcile")
     async def reconcile(
         self,
         ip_value: AllIPTypes,
-        namespace: Optional[Union[Node, str]] = None,
-        node_uuid: Optional[str] = None,
+        namespace: Node | str | None = None,
+        node_uuid: str | None = None,
         is_delete: bool = False,
-        at: Optional[Timestamp] = None,
-    ) -> Optional[Node]:
+        at: Timestamp | None = None,
+    ) -> Node | None:
         self.at = Timestamp(at)
 
         query = await IPPrefixReconcileQuery.init(
@@ -152,7 +152,7 @@ class IpamReconciler:
 
         return reconcile_nodes.node
 
-    async def _update_node_parent(self, node: Node, new_parent_uuid: Optional[str]) -> None:
+    async def _update_node_parent(self, node: Node, new_parent_uuid: str | None) -> None:
         node_kinds = {node.get_kind()} | set(node.get_schema().inherit_from)
         is_prefix = False
         if InfrahubKind.IPADDRESS in node_kinds:

infrahub/core/ipam/utilization.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.node import Node
@@ -19,9 +18,7 @@ class PrefixChildDetails:
 
 
 class PrefixUtilizationGetter:
-    def __init__(
-        self, db: InfrahubDatabase, ip_prefixes: list[Node], at: Optional[Union[Timestamp, str]] = None
-    ) -> None:
+    def __init__(self, db: InfrahubDatabase, ip_prefixes: list[Node], at: Timestamp | str | None = None) -> None:
         self.db = db
         self.ip_prefixes = ip_prefixes
         self.at = at
@@ -66,9 +63,9 @@ class PrefixUtilizationGetter:
 
     async def get_children(
         self,
-        ip_prefixes: Optional[list[Node]] = None,
-        prefix_member_type: Optional[PrefixMemberType] = None,
-        branch_names: Optional[list[str]] = None,
+        ip_prefixes: list[Node] | None = None,
+        prefix_member_type: PrefixMemberType | None = None,
+        branch_names: list[str] | None = None,
     ) -> list[PrefixChildDetails]:
         await self._fetch_data()
         prefix_child_details_list: list[PrefixChildDetails] = []
@@ -90,9 +87,9 @@ class PrefixUtilizationGetter:
 
     async def get_num_children_in_use(
         self,
-        ip_prefixes: Optional[list[Node]] = None,
-        prefix_member_type: Optional[PrefixMemberType] = None,
-        branch_names: Optional[list[str]] = None,
+        ip_prefixes: list[Node] | None = None,
+        prefix_member_type: PrefixMemberType | None = None,
+        branch_names: list[str] | None = None,
     ) -> int:
         children = await self.get_children(
             ip_prefixes=ip_prefixes, prefix_member_type=prefix_member_type, branch_names=branch_names
@@ -100,7 +97,7 @@ class PrefixUtilizationGetter:
         return len(children)
 
     async def _get_prefix_use_fraction(
-        self, ip_prefixes: Optional[list[Node]] = None, branch_names: Optional[list[str]] = None
+        self, ip_prefixes: list[Node] | None = None, branch_names: list[str] | None = None
     ) -> tuple[int, int]:
         total_prefix_space = 0
         total_used_space = 0
@@ -117,7 +114,7 @@ class PrefixUtilizationGetter:
         return total_used_space, total_prefix_space
 
     async def _get_address_use_fraction(
-        self, ip_prefixes: Optional[list[Node]] = None, branch_names: Optional[list[str]] = None
+        self, ip_prefixes: list[Node] | None = None, branch_names: list[str] | None = None
     ) -> tuple[int, int]:
         total_prefix_space = 0
         if ip_prefixes is None:
@@ -130,7 +127,7 @@ class PrefixUtilizationGetter:
         return total_used_space, total_prefix_space
 
     async def get_use_percentage(
-        self, ip_prefixes: Optional[list[Node]] = None, branch_names: Optional[list[str]] = None
+        self, ip_prefixes: list[Node] | None = None, branch_names: list[str] | None = None
     ) -> float:
         grand_total_used, grand_total_space = 0, 0
         address_prefixes, prefix_prefixes = [], []