orchestrator-core 3.1.2rc3__py3-none-any.whl → 3.2.0__py3-none-any.whl

orchestrator/domain/base.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF, ESnet.
+# Copyright 2019-2025 SURF, ESnet, GÉANT.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -12,14 +12,16 @@
 # limitations under the License.
 import itertools
 from collections import defaultdict
-from collections.abc import Callable, Iterable
 from datetime import datetime
-from inspect import get_annotations
+from inspect import get_annotations, isclass
 from itertools import groupby, zip_longest
 from operator import attrgetter
 from typing import (
     Any,
+    Callable,
     ClassVar,
+    Iterable,
+    Mapping,
     Optional,
     TypeVar,
     Union,
@@ -34,7 +36,7 @@ from more_itertools import bucket, first, flatten, one, only
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
 from pydantic.fields import PrivateAttr
 from sqlalchemy import select
-from sqlalchemy.orm import selectinload
+from sqlalchemy.orm import joinedload, selectinload
 
 from orchestrator.db import (
     ProductBlockTable,
@@ -45,13 +47,19 @@ from orchestrator.db import (
     SubscriptionTable,
     db,
 )
-from orchestrator.domain.helpers import _to_product_block_field_type_iterable
+from orchestrator.db.queries.subscription_instance import get_subscription_instance_dict
+from orchestrator.domain.helpers import (
+    _to_product_block_field_type_iterable,
+    get_root_blocks_to_instance_ids,
+    no_private_attrs,
+)
 from orchestrator.domain.lifecycle import (
     ProductLifecycle,
     lookup_specialized_type,
     register_specialized_type,
     validate_lifecycle_status,
 )
+from orchestrator.domain.subscription_instance_transform import field_transformation_rules, transform_instance_fields
 from orchestrator.services.products import get_product_by_id
 from orchestrator.types import (
     SAFE_USED_BY_TRANSITIONS_FOR_STATUS,
@@ -96,6 +104,12 @@ class DomainModel(BaseModel):
     def __init_subclass__(cls, *args: Any, lifecycle: list[SubscriptionLifecycle] | None = None, **kwargs: Any) -> None:
         pass
 
+    def __eq__(self, other: Any) -> bool:
+        # PrivateAttr fields are excluded from both objects during the equality check.
+        # Added for #652 primarily because ProductBlockModel._db_model is now lazy loaded.
+        with no_private_attrs(self), no_private_attrs(other):
+            return super().__eq__(other)
+
     @classmethod
     def __pydantic_init_subclass__(
         cls,
@@ -308,12 +322,7 @@ class DomainModel(BaseModel):
         for product_block_field_name, product_block_field_type in cls._product_block_fields_.items():
             filter_func = match_domain_model_attr_if_possible(product_block_field_name)
 
-            product_block_model: Any = product_block_field_type
-            if is_list_type(product_block_field_type):
-                _origin, args = get_origin_and_args(product_block_field_type)
-                product_block_model = one(args)
-
-            possible_product_block_types = get_possible_product_block_types(product_block_model)
+            possible_product_block_types = flatten_product_block_types(product_block_field_type)
             field_type_names = list(possible_product_block_types.keys())
             filtered_instances = flatten([grouped_instances.get(name, []) for name in field_type_names])
             instance_list = list(filter(filter_func, filtered_instances))
@@ -456,6 +465,15 @@ class DomainModel(BaseModel):
             raise ValueError(f"Cannot link the same subscription instance multiple times: {details}")
 
 
+def flatten_product_block_types(product_block_field_type: Any) -> dict[str, type["ProductBlockModel"]]:
+    """Extract product block types and return mapping of product block names to product block classes."""
+    product_block_model: Any = product_block_field_type
+    if is_list_type(product_block_field_type):
+        _origin, args = get_origin_and_args(product_block_field_type)
+        product_block_model = one(args)
+    return get_possible_product_block_types(product_block_model)
+
+
 def get_depends_on_product_block_type_list(
     product_block_types: dict[str, type["ProductBlockModel"] | tuple[type["ProductBlockModel"]]],
 ) -> list[type["ProductBlockModel"]]:
@@ -520,7 +538,7 @@ class ProductBlockModel(DomainModel):
     product_block_id: ClassVar[UUID]
     description: ClassVar[str]
     tag: ClassVar[str]
-    _db_model: SubscriptionInstanceTable = PrivateAttr()
+    _db_model: SubscriptionInstanceTable | None = PrivateAttr(default=None)
 
     # Product block name. This needs to be an instance var because its part of the API (we expose it to the frontend)
     # Is actually optional since abstract classes don't have it.
@@ -596,7 +614,9 @@ class ProductBlockModel(DomainModel):
         product_blocks_in_model = cls._get_depends_on_product_block_types()
         product_blocks_types_in_model = get_depends_on_product_block_type_list(product_blocks_in_model)
 
-        product_blocks_in_model = set(flatten(map(attrgetter("__names__"), product_blocks_types_in_model)))  # type: ignore
+        product_blocks_in_model = set(
+            flatten(map(attrgetter("__names__"), product_blocks_types_in_model))
+        )  # type: ignore
 
         missing_product_blocks_in_db = product_blocks_in_model - product_blocks_in_db  # type: ignore
         missing_product_blocks_in_model = product_blocks_in_db - product_blocks_in_model  # type: ignore
@@ -677,7 +697,7 @@ class ProductBlockModel(DomainModel):
             **sub_instances,
             **kwargs,
         )
-        model._db_model = db_model
+        model.db_model = db_model
         return model
 
     @classmethod
@@ -733,7 +753,7 @@ class ProductBlockModel(DomainModel):
 
         cls._fix_pb_data()
         model = cls(**data)
-        model._db_model = other._db_model
+        model.db_model = other.db_model
         return model
 
     @classmethod
@@ -791,7 +811,7 @@ class ProductBlockModel(DomainModel):
                 **instance_values,  # type: ignore
                 **sub_instances,
             )
-            model._db_model = subscription_instance
+            model.db_model = subscription_instance
 
             return model
         except ValidationError:
@@ -909,14 +929,15 @@ class ProductBlockModel(DomainModel):
 
             # If this is a "foreign" instance we just stop saving and return it so only its relation is saved
             # We should not touch these themselves
-            if self.subscription and subscription_instance.subscription_id != subscription_id:
+            if self.owner_subscription_id != subscription_id:
                 return [], subscription_instance
 
-            self._db_model = subscription_instance
-        else:
-            subscription_instance = self._db_model
+            self.db_model = subscription_instance
+        elif subscription_instance := self.db_model:
             # We only need to add to the session if the subscription_instance does not exist.
             db.session.add(subscription_instance)
+        else:
+            raise ValueError("Cannot save ProductBlockModel without a db_model")
 
         subscription_instance.subscription_id = subscription_id
 
@@ -943,22 +964,32 @@ class ProductBlockModel(DomainModel):
         return sub_instances + [subscription_instance], subscription_instance
 
     @property
-    def subscription(self) -> SubscriptionTable:
-        return self.db_model.subscription
+    def subscription(self) -> SubscriptionTable | None:
+        return self.db_model.subscription if self.db_model else None
 
     @property
-    def db_model(self) -> SubscriptionInstanceTable:
+    def db_model(self) -> SubscriptionInstanceTable | None:
+        if not self._db_model:
+            self._db_model = db.session.execute(
+                select(SubscriptionInstanceTable).where(
+                    SubscriptionInstanceTable.subscription_instance_id == self.subscription_instance_id
+                )
+            ).scalar_one_or_none()
         return self._db_model
 
+    @db_model.setter
+    def db_model(self, value: SubscriptionInstanceTable) -> None:
+        self._db_model = value
+
     @property
-    def in_use_by(self) -> list[SubscriptionInstanceTable]:
+    def in_use_by(self) -> list[SubscriptionInstanceTable]:  # TODO check where used, might need eagerloading
         """This provides a list of product blocks that depend on this product block."""
-        return self._db_model.in_use_by
+        return self.db_model.in_use_by if self.db_model else []
 
     @property
-    def depends_on(self) -> list[SubscriptionInstanceTable]:
+    def depends_on(self) -> list[SubscriptionInstanceTable]:  # TODO check where used, might need eagerloading
         """This provides a list of product blocks that this product block depends on."""
-        return self._db_model.depends_on
+        return self.db_model.depends_on if self.db_model else []
 
 
 class ProductModel(BaseModel):
@@ -1006,9 +1037,11 @@ class SubscriptionModel(DomainModel):
         >>> SubscriptionInactive.from_subscription(subscription_id)  # doctest:+SKIP
     """
 
+    __model_dump_cache__: ClassVar[dict[UUID, "SubscriptionModel"] | None] = None
+
     product: ProductModel
     customer_id: str
-    _db_model: SubscriptionTable = PrivateAttr()
+    _db_model: SubscriptionTable | None = PrivateAttr(default=None)
     subscription_id: UUID = Field(default_factory=uuid4)  # pragma: no mutate
     description: str = "Initial subscription"  # pragma: no mutate
     status: SubscriptionLifecycle = SubscriptionLifecycle.INITIAL  # pragma: no mutate
@@ -1051,7 +1084,9 @@ class SubscriptionModel(DomainModel):
         product_blocks_in_model = cls._get_depends_on_product_block_types()
         product_blocks_types_in_model = get_depends_on_product_block_type_list(product_blocks_in_model)
 
-        product_blocks_in_model = set(flatten(map(attrgetter("__names__"), product_blocks_types_in_model)))  # type: ignore
+        product_blocks_in_model = set(
+            flatten(map(attrgetter("__names__"), product_blocks_types_in_model))
+        )  # type: ignore
 
         missing_product_blocks_in_db = product_blocks_in_model - product_blocks_in_db  # type: ignore
         missing_product_blocks_in_model = product_blocks_in_db - product_blocks_in_model  # type: ignore
@@ -1097,6 +1132,63 @@ class SubscriptionModel(DomainModel):
 
         return missing_data
 
+    @classmethod
+    def _load_root_instances(
+        cls,
+        subscription_id: UUID | UUIDstr,
+    ) -> dict[str, Optional[dict] | list[dict]]:
+        """Load root subscription instance(s) for this subscription model.
+
+        When a new subscription model is loaded from an existing subscription, this function loads the entire root
+        subscription instance(s) from database using an optimized postgres function. The result of that function
+        is used to instantiate the root product block(s).
+
+        The "old" method DomainModel._load_instances() would recursively load subscription instances from the
+        database and individually instantiate nested blocks, more or less "manually" reconstructing the subscription.
+
+        The "new" method SubscriptionModel._load_root_instances() takes a different approach; since it has all
+        data for the root subscription instance, it can rely on Pydantic to instantiate the root block and all
+        nested blocks in one go. This is also why it does not have the params `status` and `match_domain_attr` because
+        this information is already encoded in the domain model of a product.
+        """
+        root_block_instance_ids = get_root_blocks_to_instance_ids(subscription_id)
+
+        root_block_types = {
+            field_name: list(flatten_product_block_types(product_block_type).keys())
+            for field_name, product_block_type in cls._product_block_fields_.items()
+        }
+
+        def get_instances_by_block_names(block_names: list[str]) -> Iterable[dict]:
+            for block_name in block_names:
+                for instance_id in root_block_instance_ids.get(block_name, []):
+                    yield get_subscription_instance_dict(instance_id)
+
+        # Map root product block fields to subscription instance(s) dicts
+        instances = {
+            field_name: list(get_instances_by_block_names(block_names))
+            for field_name, block_names in root_block_types.items()
+        }
+
+        # Transform values according to domain models (list[dict] -> dict, add None as default for optionals)
+        rules = {
+            klass.name: field_transformation_rules(klass) for klass in ProductBlockModel.registry.values() if klass.name
+        }
+        for instance_list in instances.values():
+            for instance in instance_list:
+                transform_instance_fields(rules, instance)
+
+        # Support the (theoretical?) usecase of a list of root product blocks
+        def unpack_instance_list(field_name: str, instance_list: list[dict]) -> list[dict] | dict | None:
+            field_type = cls._product_block_fields_[field_name]
+            if is_list_type(field_type):
+                return instance_list
+            return only(instance_list)
+
+        return {
+            field_name: unpack_instance_list(field_name, instance_list)
+            for field_name, instance_list in instances.items()
+        }
+
     @classmethod
     def from_product_id(
         cls: type[S],
@@ -1162,7 +1254,7 @@ class SubscriptionModel(DomainModel):
             **fixed_inputs,
             **instances,
         )
-        model._db_model = subscription
+        model.db_model = subscription
         return model
 
     @classmethod
@@ -1195,17 +1287,26 @@ class SubscriptionModel(DomainModel):
             data["end_date"] = nowtz()
 
         model = cls(**data)
-        model._db_model = other._db_model
+        model.db_model = other._db_model
 
         return model
 
     # Some common functions shared by from_other_product and from_subscription
     @classmethod
-    def _get_subscription(cls: type[S], subscription_id: UUID | UUIDstr) -> Any:
-        return db.session.get(
-            SubscriptionTable,
-            subscription_id,
-            options=[
+    def _get_subscription(cls: type[S], subscription_id: UUID | UUIDstr) -> SubscriptionTable | None:
+        from orchestrator.settings import app_settings
+
+        if not isinstance(subscription_id, UUID | UUIDstr):
+            raise TypeError(f"subscription_id is of type {type(subscription_id)} instead of UUID | UUIDstr")
+
+        if app_settings.ENABLE_SUBSCRIPTION_MODEL_OPTIMIZATIONS:
+            # TODO #900 remove toggle and make this path the default
+            loaders = [
+                joinedload(SubscriptionTable.product).selectinload(ProductTable.fixed_inputs),
+            ]
+
+        else:
+            loaders = [
                 selectinload(SubscriptionTable.instances)
                 .joinedload(SubscriptionInstanceTable.product_block)
                 .selectinload(ProductBlockTable.resource_types),
@@ -1213,8 +1314,9 @@ class SubscriptionModel(DomainModel):
                     SubscriptionInstanceTable.in_use_by_block_relations
                 ),
                 selectinload(SubscriptionTable.instances).selectinload(SubscriptionInstanceTable.values),
-            ],
-        )
+            ]
+
+        return db.session.get(SubscriptionTable, subscription_id, options=loaders)
 
     @classmethod
     def _to_product_model(cls: type[S], product: ProductTable) -> ProductModel:
@@ -1240,7 +1342,9 @@ class SubscriptionModel(DomainModel):
         if not db_product:
             raise KeyError("Could not find a product for the given product_id")
 
-        subscription = cls._get_subscription(old_instantiation.subscription_id)
+        old_subscription_id = old_instantiation.subscription_id
+        if not (subscription := cls._get_subscription(old_subscription_id)):
+            raise ValueError(f"Subscription with id: {old_subscription_id}, does not exist")
         product = cls._to_product_model(db_product)
 
         status = SubscriptionLifecycle(subscription.status)
@@ -1260,6 +1364,7 @@ class SubscriptionModel(DomainModel):
             name, product_block = new_root
             instances = {name: product_block}
         else:
+            # TODO test using cls._load_root_instances() here as well
             instances = cls._load_instances(subscription.instances, status, match_domain_attr=False)  # type:ignore
 
         try:
@@ -1277,7 +1382,7 @@ class SubscriptionModel(DomainModel):
                 **fixed_inputs,
                 **instances,
             )
-            model._db_model = subscription
+            model.db_model = subscription
             return model
         except ValidationError:
             logger.exception(
@@ -1288,8 +1393,13 @@ class SubscriptionModel(DomainModel):
     @classmethod
     def from_subscription(cls: type[S], subscription_id: UUID | UUIDstr) -> S:
         """Use a subscription_id to return required fields of an existing subscription."""
-        subscription = cls._get_subscription(subscription_id)
-        if subscription is None:
+        from orchestrator.domain.context_cache import get_from_cache, store_in_cache
+        from orchestrator.settings import app_settings
+
+        if cached_model := get_from_cache(subscription_id):
+            return cast(S, cached_model)
+
+        if not (subscription := cls._get_subscription(subscription_id)):
             raise ValueError(f"Subscription with id: {subscription_id}, does not exist")
         product = cls._to_product_model(subscription.product)
 
@@ -1311,7 +1421,12 @@ class SubscriptionModel(DomainModel):
 
         fixed_inputs = {fi.name: fi.value for fi in subscription.product.fixed_inputs}
 
-        instances = cls._load_instances(subscription.instances, status, match_domain_attr=False)
+        instances: dict[str, Any]
+        if app_settings.ENABLE_SUBSCRIPTION_MODEL_OPTIMIZATIONS:
+            # TODO #900 remove toggle and make this path the default
+            instances = cls._load_root_instances(subscription_id)
+        else:
+            instances = cls._load_instances(subscription.instances, status, match_domain_attr=False)
 
         try:
             model = cls(
@@ -1328,7 +1443,10 @@ class SubscriptionModel(DomainModel):
                 **fixed_inputs,
                 **instances,
             )
-            model._db_model = subscription
+            model.db_model = subscription
+
+            store_in_cache(model)
+
             return model
         except ValidationError:
             logger.exception(
@@ -1344,7 +1462,7 @@ class SubscriptionModel(DomainModel):
                 f"Lifecycle status {self.status.value} requires specialized type {specialized_type!r}, was: {type(self)!r}"
             )
 
-        sub = db.session.get(
+        existing_sub = db.session.get(
             SubscriptionTable,
             self.subscription_id,
             options=[
@@ -1354,13 +1472,13 @@ class SubscriptionModel(DomainModel):
                 selectinload(SubscriptionTable.instances).selectinload(SubscriptionInstanceTable.values),
             ],
         )
-        if not sub:
-            sub = self._db_model
+        if not (sub := (existing_sub or self.db_model)):
+            raise ValueError("Cannot save SubscriptionModel without a db_model")
 
         # Make sure we refresh the object and not use an already mapped object
         db.session.refresh(sub)
 
-        self._db_model = sub
+        self.db_model = sub
         sub.product_id = self.product.product_id
         sub.customer_id = self.customer_id
         sub.description = self.description
@@ -1398,9 +1516,78 @@ class SubscriptionModel(DomainModel):
         db.session.flush()
 
     @property
-    def db_model(self) -> SubscriptionTable:
+    def db_model(self) -> SubscriptionTable | None:
+        if not self._db_model:
+            self._db_model = self._get_subscription(self.subscription_id)
         return self._db_model
 
+    @db_model.setter
+    def db_model(self, value: SubscriptionTable) -> None:
+        self._db_model = value
+
+
+def validate_base_model(
+    name: str, cls: type[Any], base_model: type[BaseModel] = DomainModel, errors: list[str] | None = None
+) -> None:
+    """Validates that the given class is not Pydantic BaseModel or its direct subclass."""
+    # Instantiate errors list if not provided and avoid mutating default
+    if errors is None:
+        errors = []
+    # Return early when the node is not a class as there is nothing to be done
+    if not isclass(cls):
+        return
+    # Validate each field in the ProductBlockModel's field dictionaries
+    if issubclass(cls, ProductBlockModel) or issubclass(cls, SubscriptionModel):
+        for name, clz in cls._product_block_fields_.items():
+            validate_base_model(name, clz, ProductBlockModel, errors)
+        for name, clz in cls._non_product_block_fields_.items():
+            validate_base_model(name, clz, SubscriptionModel, errors)
+    # Generate error if node is Pydantic BaseModel or direct subclass
+    if issubclass(cls, BaseModel):
+        err_msg: str = (
+            f"If this field was intended to be a {base_model.__name__}, define {name}:{cls.__name__} with "
+            f"{base_model.__name__} as its superclass instead. e.g., class {cls.__name__}({base_model.__name__}):"
+        )
+        if cls is BaseModel:
+            errors.append(f"Field {name}: {cls.__name__} can not be {BaseModel.__name__}. " + err_msg)
+        if len(cls.__mro__) > 1 and cls.__mro__[1] is BaseModel:
+            errors.append(
+                f"Field {name}: {cls.__name__} can not be a direct subclass of {BaseModel.__name__}. " + err_msg
+            )
+    # Format all errors as one per line and raise a TypeError when they exist
+    if errors:
+        raise TypeError("\n".join(errors))
+
+
+class SubscriptionModelRegistry(dict[str, type[SubscriptionModel]]):
+    """A registry for all subscription models."""
+
+    def __setitem__(self, __key: str, __value: type[SubscriptionModel]) -> None:
+        """Set value for key in while validating against Pydantic BaseModel."""
+        validate_base_model(__key, __value)
+        super().__setitem__(__key, __value)
+
+    def update(
+        self,
+        m: Any = None,
+        /,
+        **kwargs: type[SubscriptionModel],
+    ) -> None:
+        """Update dictionary with mapping and/or kwargs using `__setitem__`."""
+        if m:
+            if isinstance(m, Mapping):
+                for key, value in m.items():
+                    self[key] = value
+            elif isinstance(m, Iterable):
+                for index, item in enumerate(m):
+                    try:
+                        key, value = item
+                    except ValueError:
+                        raise TypeError(f"dictionary update sequence element #{index} is not an iterable of length 2")
+                    self[key] = value
+        for key, value in kwargs.items():
+            self[key] = value
+
 
 def _validate_lifecycle_change_for_product_block(
     used_by: SubscriptionInstanceTable,

orchestrator/domain/context_cache.py

@@ -0,0 +1,62 @@
+# Copyright 2019-2025 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import contextlib
+from contextvars import ContextVar
+from typing import Iterator
+from uuid import UUID
+
+from orchestrator.domain import SubscriptionModel
+from pydantic_forms.types import UUIDstr
+
+__subscription_model_cache: ContextVar[dict[UUID, SubscriptionModel] | None] = ContextVar(
+    "subscription_model_cache", default=None
+)
+
+
+@contextlib.contextmanager
+def cache_subscription_models() -> Iterator:
+    """Caches SubscriptionModels for the duration of the context.
+
+    Inside this context, calling SubscriptionModel.from_subscription() twice with the same
+    subscription id will return the same instance.
+
+    The primary usecase is to improve performance of `@computed_field` properties on product blocks
+    which load other subscriptions.
+
+    Example usage:
+        subscription = SubscriptionModel.from_subscription("...")
+        with cache_subscription_models():
+           subscription_dict = subscription.model_dump()
+    """
+    before = __subscription_model_cache.set({})
+    try:
+        yield
+    finally:
+        __subscription_model_cache.reset(before)
+
+
+def get_from_cache(subscription_id: UUID | UUIDstr) -> SubscriptionModel | None:
+    """Retrieve SubscriptionModel from cache, if present."""
+    if (cache := __subscription_model_cache.get()) is None:
+        return None
+
+    id_ = subscription_id if isinstance(subscription_id, UUID) else UUID(subscription_id)
+    return cache.get(id_, None)
+
+
+def store_in_cache(model: SubscriptionModel) -> None:
+    """Store SubscriptionModel in cache, if required."""
+    if (cache := __subscription_model_cache.get()) is None:
+        return
+
+    cache[model.subscription_id] = model

orchestrator/domain/helpers.py

@@ -1,6 +1,15 @@
-from collections.abc import Iterable
+import contextlib
+from collections.abc import Iterable, Iterator
+from typing import Any
+from uuid import UUID
 
+from pydantic import BaseModel
+from sqlalchemy import select
+
+from orchestrator.db import ProductBlockTable, SubscriptionInstanceTable, db
 from orchestrator.types import filter_nonetype, get_origin_and_args, is_union_type
+from orchestrator.utils.functional import group_by_key
+from pydantic_forms.types import UUIDstr
 
 
 def _to_product_block_field_type_iterable(product_block_field_type: type | tuple[type]) -> Iterable[type]:
@@ -21,3 +30,34 @@ def _to_product_block_field_type_iterable(product_block_field_type: type | tuple
         return product_block_field_type
 
     return [product_block_field_type]
+
+
+@contextlib.contextmanager
+def no_private_attrs(model: Any) -> Iterator:
+    """PrivateAttrs from the given pydantic BaseModel are removed for the duration of this context."""
+    if not isinstance(model, BaseModel):
+        yield
+        return
+    private_attrs_reference = model.__pydantic_private__
+    try:
+        model.__pydantic_private__ = {}
+        yield
+    finally:
+        model.__pydantic_private__ = private_attrs_reference
+
+
+def get_root_blocks_to_instance_ids(subscription_id: UUID | UUIDstr) -> dict[str, list[UUID]]:
+    """Returns mapping of root product block names to list of subscription instance ids.
+
+    While recommended practice is to have only 1 root product block, it is possible to have multiple blocks or even a
+    list of root blocks. This function supports that.
+    """
+    block_name_to_instance_id_rows = db.session.execute(
+        select(ProductBlockTable.name, SubscriptionInstanceTable.subscription_instance_id)
+        .select_from(SubscriptionInstanceTable)
+        .join(ProductBlockTable)
+        .where(SubscriptionInstanceTable.subscription_id == subscription_id)
+        .order_by(ProductBlockTable.name)
+    ).all()
+
+    return group_by_key(block_name_to_instance_id_rows)  # type: ignore[arg-type]

orchestrator/domain/lifecycle.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2020 SURF, GÉANT.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at