dstack 0.0.9__py3-none-any.whl → 0.20.7__py3-none-any.whl

dstack/_internal/core/backends/nebius/resources.py

@@ -0,0 +1,433 @@
+import logging
+import re
+import time
+from collections import defaultdict
+from collections.abc import Container as ContainerT
+from collections.abc import Generator, Iterable, Sequence
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+from typing import Dict, Optional
+
+from nebius.aio.operation import Operation as SDKOperation
+from nebius.aio.service_error import RequestError, StatusCode
+from nebius.aio.token.renewable import OPTION_RENEW_REQUEST_TIMEOUT, OPTION_RENEW_SYNCHRONOUS
+from nebius.api.nebius.common.v1 import Operation, ResourceMetadata
+from nebius.api.nebius.compute.v1 import (
+    AttachedDiskSpec,
+    CreateDiskRequest,
+    CreateGpuClusterRequest,
+    CreateInstanceRequest,
+    DeleteDiskRequest,
+    DeleteGpuClusterRequest,
+    DeleteInstanceRequest,
+    DiskServiceClient,
+    DiskSpec,
+    ExistingDisk,
+    GetInstanceRequest,
+    GpuClusterServiceClient,
+    GpuClusterSpec,
+    Instance,
+    InstanceGpuClusterSpec,
+    InstanceRecoveryPolicy,
+    InstanceServiceClient,
+    InstanceSpec,
+    IPAddress,
+    NetworkInterfaceSpec,
+    PreemptibleSpec,
+    PublicIPAddress,
+    ResourcesSpec,
+    SourceImageFamily,
+)
+from nebius.api.nebius.iam.v1 import (
+    Container,
+    ListProjectsRequest,
+    ListTenantsRequest,
+    ProjectServiceClient,
+    TenantServiceClient,
+)
+from nebius.api.nebius.vpc.v1 import ListSubnetsRequest, Subnet, SubnetServiceClient
+from nebius.sdk import SDK
+
+from dstack._internal.core.backends.base.configurator import raise_invalid_credentials_error
+from dstack._internal.core.backends.base.offers import get_catalog_offers
+from dstack._internal.core.backends.nebius.models import (
+    DEFAULT_PROJECT_NAME_PREFIX,
+    NebiusOfferBackendData,
+    NebiusServiceAccountCreds,
+)
+from dstack._internal.core.errors import BackendError, NoCapacityError
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.utils.event_loop import DaemonEventLoop
+from dstack._internal.utils.logging import get_logger
+
+#
+# Guidelines on using the Nebius SDK:
+#
+# Do not use Request.wait() or other sync SDK methods, they suffer from deadlocks.
+# Instead, use async methods and await them with LOOP.await_()
+LOOP = DaemonEventLoop()
+# Pass a timeout to all methods to avoid infinite waiting
+REQUEST_TIMEOUT = 10
+# Pass REQUEST_AUTH_OPTIONS to all methods to avoid infinite retries in case of invalid credentials
+REQUEST_AUTH_OPTIONS = {
+    OPTION_RENEW_SYNCHRONOUS: "true",
+    OPTION_RENEW_REQUEST_TIMEOUT: "5",
+}
+
+# disables log messages about errors such as invalid creds or expired timeouts
+logging.getLogger("nebius").setLevel(logging.CRITICAL)
+logger = get_logger(__name__)
+
+
+@contextmanager
+def wrap_capacity_errors() -> Generator[None, None, None]:
+    try:
+        yield
+    except RequestError as e:
+        if e.status.code == StatusCode.RESOURCE_EXHAUSTED or "Quota limit exceeded" in str(e):
+            raise NoCapacityError(e)
+        raise
+
+
+@contextmanager
+def ignore_errors(status_codes: ContainerT[StatusCode]) -> Generator[None, None, None]:
+    try:
+        yield
+    except RequestError as e:
+        if e.status.code not in status_codes:
+            raise
+
+
+def make_sdk(creds: NebiusServiceAccountCreds) -> SDK:
+    with NamedTemporaryFile("w") as f:
+        f.write(creds.private_key_content)
+        f.flush()
+        return SDK(
+            service_account_private_key_file_name=f.name,
+            service_account_public_key_id=creds.public_key_id,
+            service_account_id=creds.service_account_id,
+        )
+
+
+def wait_for_operation(
+    op: SDKOperation[Operation],
+    timeout: float,
+    interval: float = 1,
+) -> None:
+    # Re-implementation of SDKOperation.wait() to avoid https://github.com/nebius/pysdk/issues/74
+    deadline = time.monotonic() + timeout
+    while not op.done():
+        if time.monotonic() + interval > deadline:
+            raise TimeoutError(f"Operation {op.id} wait timeout")
+        time.sleep(interval)
+        LOOP.await_(
+            op.update(per_retry_timeout=REQUEST_TIMEOUT, auth_options=REQUEST_AUTH_OPTIONS)
+        )
+
+
+def get_region_to_project_id_map(
+    sdk: SDK, configured_regions: Optional[list[str]], configured_project_ids: Optional[list[str]]
+) -> dict[str, str]:
+    """Validate backend settings and build region->project_id map"""
+
+    projects = list_tenant_projects(sdk)
+    if configured_regions:
+        validate_regions(
+            configured=set(configured_regions), available={p.status.region for p in projects}
+        )
+    if configured_project_ids is not None:
+        return _get_region_to_configured_project_id_map(
+            projects, configured_project_ids, configured_regions
+        )
+    else:
+        return _get_region_to_default_project_id_map(projects, configured_regions)
+
+
+def validate_regions(configured: set[str], available: set[str]) -> None:
+    if invalid := set(configured) - available:
+        raise_invalid_credentials_error(
+            fields=[["regions"]],
+            details=(
+                f"Configured regions {invalid} do not exist in this Nebius tenancy."
+                " Omit `regions` to use all regions or select some of the available regions:"
+                f" {available}"
+            ),
+        )
+
+
+def list_tenant_projects(sdk: SDK) -> Sequence[Container]:
+    tenants = LOOP.await_(
+        TenantServiceClient(sdk).list(
+            ListTenantsRequest(),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+    if len(tenants.items) != 1:
+        raise ValueError(f"Expected to find 1 tenant, found {(len(tenants.items))}")
+    tenant_id = tenants.items[0].metadata.id
+    projects = LOOP.await_(
+        ProjectServiceClient(sdk).list(
+            ListProjectsRequest(parent_id=tenant_id, page_size=999),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+    return projects.items
+
+
+def _get_region_to_default_project_id_map(
+    all_tenant_projects: Iterable[Container], configured_regions: Optional[list[str]]
+) -> dict[str, str]:
+    region_to_projects: defaultdict[str, list[Container]] = defaultdict(list)
+    for project in all_tenant_projects:
+        region_to_projects[project.status.region].append(project)
+    region_to_project_id = {}
+    for region, region_projects in region_to_projects.items():
+        if configured_regions and region not in configured_regions:
+            continue
+        if len(region_projects) != 1:
+            region_projects = [
+                p
+                for p in region_projects
+                if p.metadata.name.startswith(DEFAULT_PROJECT_NAME_PREFIX)
+            ]
+            if len(region_projects) != 1:
+                raise_invalid_credentials_error(
+                    ["regions"],
+                    (
+                        f"Could not find the default project in region {region}."
+                        " Consider setting the `projects` property in backend settings"
+                    ),
+                )
+        region_to_project_id[region] = region_projects[0].metadata.id
+    return region_to_project_id
+
+
+def _get_region_to_configured_project_id_map(
+    all_tenant_projects: Iterable[Container],
+    configured_project_ids: list[str],
+    configured_regions: Optional[list[str]],
+) -> dict[str, str]:
+    project_id_to_project = {p.metadata.id: p for p in all_tenant_projects}
+    region_to_project_id = {}
+    for project_id in configured_project_ids:
+        project = project_id_to_project.get(project_id)
+        if project is None:
+            raise_invalid_credentials_error(
+                ["projects"],
+                f"Configured project ID {project_id!r} not found in this Nebius tenancy",
+            )
+        duplicate_project_id = region_to_project_id.get(project.status.region)
+        if duplicate_project_id:
+            raise_invalid_credentials_error(
+                ["projects"],
+                (
+                    f"Configured projects {project_id} and {duplicate_project_id}"
+                    f" both belong to the same region {project.status.region}."
+                    " Only one project per region is allowed"
+                ),
+            )
+        region_to_project_id[project.status.region] = project_id
+    if configured_regions:
+        # only filter by region after validating all project IDs
+        return {
+            region: project_id
+            for region, project_id in region_to_project_id.items()
+            if region in configured_regions
+        }
+    return region_to_project_id
+
+
+def get_default_subnet(sdk: SDK, project_id: str) -> Subnet:
+    subnets = LOOP.await_(
+        SubnetServiceClient(sdk).list(
+            ListSubnetsRequest(parent_id=project_id, page_size=999),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+    for subnet in subnets.items:
+        if subnet.metadata.name.startswith("default-subnet"):
+            return subnet
+    raise BackendError(f"Could not find default subnet in project {project_id}")
+
+
+def get_all_infiniband_fabrics() -> set[str]:
+    offers = get_catalog_offers(backend=BackendType.NEBIUS)
+    result = set()
+    for offer in offers:
+        backend_data: NebiusOfferBackendData = NebiusOfferBackendData.__response__.parse_obj(
+            offer.backend_data
+        )
+        result |= backend_data.fabrics
+    return result
+
+
+def create_disk(
+    sdk: SDK, name: str, project_id: str, size_mib: int, image_family: str, labels: Dict[str, str]
+) -> SDKOperation[Operation]:
+    client = DiskServiceClient(sdk)
+    request = CreateDiskRequest(
+        metadata=ResourceMetadata(
+            name=name,
+            parent_id=project_id,
+            labels=labels,
+        ),
+        spec=DiskSpec(
+            size_mebibytes=size_mib,
+            type=DiskSpec.DiskType.NETWORK_SSD,
+            source_image_family=SourceImageFamily(image_family=image_family),
+        ),
+    )
+    with wrap_capacity_errors():
+        return LOOP.await_(
+            client.create(
+                request, per_retry_timeout=REQUEST_TIMEOUT, auth_options=REQUEST_AUTH_OPTIONS
+            )
+        )
+
+
+def delete_disk(sdk: SDK, disk_id: str) -> None:
+    LOOP.await_(
+        DiskServiceClient(sdk).delete(
+            DeleteDiskRequest(id=disk_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+
+
+def create_instance(
+    sdk: SDK,
+    name: str,
+    project_id: str,
+    user_data: str,
+    platform: str,
+    preset: str,
+    cluster_id: Optional[str],
+    disk_id: str,
+    subnet_id: str,
+    preemptible: bool,
+    labels: Dict[str, str],
+) -> SDKOperation[Operation]:
+    client = InstanceServiceClient(sdk)
+    request = CreateInstanceRequest(
+        metadata=ResourceMetadata(
+            name=name,
+            parent_id=project_id,
+            labels=labels,
+        ),
+        spec=InstanceSpec(
+            cloud_init_user_data=user_data,
+            resources=ResourcesSpec(platform=platform, preset=preset),
+            gpu_cluster=InstanceGpuClusterSpec(id=cluster_id) if cluster_id is not None else None,
+            boot_disk=AttachedDiskSpec(
+                attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE,
+                existing_disk=ExistingDisk(id=disk_id),
+            ),
+            network_interfaces=[
+                NetworkInterfaceSpec(
+                    name="dstack-default-interface",
+                    subnet_id=subnet_id,
+                    ip_address=IPAddress(),
+                    public_ip_address=PublicIPAddress(static=True),
+                )
+            ],
+            preemptible=PreemptibleSpec(
+                priority=1, on_preemption=PreemptibleSpec.PreemptionPolicy.STOP
+            )
+            if preemptible
+            else None,
+            recovery_policy=InstanceRecoveryPolicy.FAIL if preemptible else None,
+        ),
+    )
+    with wrap_capacity_errors():
+        return LOOP.await_(
+            client.create(
+                request, per_retry_timeout=REQUEST_TIMEOUT, auth_options=REQUEST_AUTH_OPTIONS
+            )
+        )
+
+
+def get_instance(sdk: SDK, instance_id: str) -> Instance:
+    return LOOP.await_(
+        InstanceServiceClient(sdk).get(
+            GetInstanceRequest(id=instance_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+
+
+def delete_instance(sdk: SDK, instance_id: str) -> SDKOperation[Operation]:
+    return LOOP.await_(
+        InstanceServiceClient(sdk).delete(
+            DeleteInstanceRequest(id=instance_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+
+
+def create_cluster(sdk: SDK, name: str, project_id: str, fabric: str) -> SDKOperation[Operation]:
+    with wrap_capacity_errors():
+        return LOOP.await_(
+            GpuClusterServiceClient(sdk).create(
+                CreateGpuClusterRequest(
+                    metadata=ResourceMetadata(name=name, parent_id=project_id),
+                    spec=GpuClusterSpec(infiniband_fabric=fabric),
+                ),
+                per_retry_timeout=REQUEST_TIMEOUT,
+                auth_options=REQUEST_AUTH_OPTIONS,
+            )
+        )
+
+
+def delete_cluster(sdk: SDK, cluster_id: str) -> None:
+    LOOP.await_(
+        GpuClusterServiceClient(sdk).delete(
+            DeleteGpuClusterRequest(id=cluster_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            auth_options=REQUEST_AUTH_OPTIONS,
+        )
+    )
+
+
+def filter_invalid_labels(labels: Dict[str, str]) -> Dict[str, str]:
+    filtered_labels = {}
+    for k, v in labels.items():
+        if not _is_valid_label(k, v):
+            logger.warning("Skipping invalid label '%s: %s'", k, v)
+            continue
+        filtered_labels[k] = v
+    return filtered_labels
+
+
+def validate_labels(labels: Dict[str, str]):
+    for k, v in labels.items():
+        if not _is_valid_label(k, v):
+            raise BackendError("Invalid resource labels")
+
+
+def _is_valid_label(key: str, value: str) -> bool:
+    # TODO: [Nebius] current validation logic reuses GCP's approach.
+    #   There is no public information on Nebius labels restrictions.
+    return is_valid_resource_name(key) and is_valid_label_value(value)
+
+
+MAX_RESOURCE_NAME_LEN = 63
+NAME_PATTERN = re.compile(r"^[a-z][_\-a-z0-9]{0,62}$")
+LABEL_VALUE_PATTERN = re.compile(r"^[_\-a-z0-9]{0,63}$")
+
+
+def is_valid_resource_name(name: str) -> bool:
+    if len(name) < 1 or len(name) > MAX_RESOURCE_NAME_LEN:
+        return False
+    match = re.match(NAME_PATTERN, name)
+    return match is not None
+
+
+def is_valid_label_value(value: str) -> bool:
+    match = re.match(LABEL_VALUE_PATTERN, value)
+    return match is not None

dstack/_internal/core/backends/oci/auth.py

@@ -0,0 +1,21 @@
+import oci
+from typing_extensions import Any, Mapping
+
+from dstack._internal.core.backends.oci.exceptions import any_oci_exception
+from dstack._internal.core.backends.oci.models import AnyOCICreds, OCIDefaultCreds
+
+
+def get_client_config(creds: AnyOCICreds) -> Mapping[str, Any]:
+    if isinstance(creds, OCIDefaultCreds):
+        return oci.config.from_file(file_location=creds.file, profile_name=creds.profile)
+    return creds.dict(exclude={"type"})
+
+
+def creds_valid(creds: AnyOCICreds) -> bool:
+    try:
+        config = get_client_config(creds)
+        client = oci.identity.IdentityClient(config)
+        client.get_tenancy(config["tenancy"])
+    except any_oci_exception:
+        return False
+    return True

dstack/_internal/core/backends/oci/backend.py

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.oci.compute import OCICompute
+from dstack._internal.core.backends.oci.models import OCIConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class OCIBackend(Backend):
+    TYPE = BackendType.OCI
+    COMPUTE_CLASS = OCICompute
+
+    def __init__(self, config: OCIConfig):
+        self.config = config
+        self._compute = OCICompute(self.config)
+
+    def compute(self) -> OCICompute:
+        return self._compute

dstack/_internal/core/backends/oci/compute.py

@@ -0,0 +1,209 @@
+from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor
+from functools import cached_property
+from typing import List, Optional
+
+import oci
+
+from dstack._internal.core.backends.base.compute import (
+    Compute,
+    ComputeWithAllOffersCached,
+    ComputeWithCreateInstanceSupport,
+    ComputeWithMultinodeSupport,
+    ComputeWithPrivilegedSupport,
+    generate_unique_instance_name,
+    get_user_data,
+)
+from dstack._internal.core.backends.base.offers import (
+    OfferModifier,
+    get_catalog_offers,
+    get_offers_disk_modifier,
+)
+from dstack._internal.core.backends.oci import resources
+from dstack._internal.core.backends.oci.models import OCIConfig
+from dstack._internal.core.backends.oci.region import make_region_clients_map
+from dstack._internal.core.errors import NoCapacityError
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.core.models.instances import (
+    InstanceAvailability,
+    InstanceConfiguration,
+    InstanceOffer,
+    InstanceOfferWithAvailability,
+)
+from dstack._internal.core.models.placement import PlacementGroup
+from dstack._internal.core.models.resources import Memory, Range
+from dstack._internal.core.models.runs import JobProvisioningData, Requirements
+
+SUPPORTED_SHAPE_FAMILIES = [
+    "VM.Standard2.",
+    "BM.Standard2.",
+    "BM.Standard3.",
+    "BM.Standard.E3.",
+    "BM.Standard.E4.",
+    "BM.Standard.E5.",
+    "BM.Optimized3.",
+    "VM.GPU2.",
+    "BM.GPU2.",
+    "VM.GPU3.",
+    "BM.GPU3.",
+    "BM.GPU4.",
+    "VM.GPU.A10.",
+    "BM.GPU.A10.",
+]
+CONFIGURABLE_DISK_SIZE = Range[Memory](min=Memory.parse("50GB"), max=Memory.parse("32TB"))
+
+
+class OCICompute(
+    ComputeWithAllOffersCached,
+    ComputeWithCreateInstanceSupport,
+    ComputeWithPrivilegedSupport,
+    ComputeWithMultinodeSupport,
+    Compute,
+):
+    def __init__(self, config: OCIConfig):
+        super().__init__()
+        self.config = config
+        self.regions = make_region_clients_map(config.regions or [], config.creds)
+
+    @cached_property
+    def shapes_quota(self) -> resources.ShapesQuota:
+        return resources.ShapesQuota.load(self.regions, self.config.compartment_id)
+
+    def get_all_offers_with_availability(self) -> List[InstanceOfferWithAvailability]:
+        offers = get_catalog_offers(
+            backend=BackendType.OCI,
+            locations=self.config.regions,
+            extra_filter=_supported_instances,
+        )
+
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            shapes_availability = resources.get_shapes_availability(
+                offers, self.shapes_quota, self.regions, self.config.compartment_id, executor
+            )
+
+        offers_with_availability = []
+        for offer in offers:
+            if offer.instance.name in shapes_availability[offer.region]:
+                availability = InstanceAvailability.AVAILABLE
+            elif self.shapes_quota.is_within_region_quota(offer.instance.name, offer.region):
+                availability = InstanceAvailability.NOT_AVAILABLE
+            else:
+                availability = InstanceAvailability.NO_QUOTA
+            offers_with_availability.append(
+                InstanceOfferWithAvailability(
+                    **offer.dict(),
+                    availability=availability,
+                    availability_zones=shapes_availability[offer.region].get(
+                        offer.instance.name, []
+                    ),
+                )
+            )
+
+        return offers_with_availability
+
+    def get_offers_modifiers(self, requirements: Requirements) -> Iterable[OfferModifier]:
+        return [get_offers_disk_modifier(CONFIGURABLE_DISK_SIZE, requirements)]
+
+    def terminate_instance(
+        self, instance_id: str, region: str, backend_data: Optional[str] = None
+    ) -> None:
+        region_client = self.regions[region]
+        resources.terminate_instance_if_exists(region_client.compute_client, instance_id)
+
+    def create_instance(
+        self,
+        instance_offer: InstanceOfferWithAvailability,
+        instance_config: InstanceConfiguration,
+        placement_group: Optional[PlacementGroup],
+    ) -> JobProvisioningData:
+        region = self.regions[instance_offer.region]
+
+        if not instance_offer.availability_zones:
+            raise NoCapacityError("Shape unavailable in all availability domains")
+        availability_domain = instance_offer.availability_zones[0]
+
+        listing, package = resources.get_marketplace_listing_and_package(
+            gpu_name=(
+                instance_offer.instance.resources.gpus[0].name
+                if len(instance_offer.instance.resources.gpus) > 0
+                else None
+            ),
+            client=region.marketplace_client,
+        )
+        resources.accept_marketplace_listing_agreements(
+            listing, self.config.compartment_id, region.marketplace_client
+        )
+
+        subnet: oci.core.models.Subnet = region.virtual_network_client.get_subnet(
+            self.config.subnet_ids_per_region[instance_offer.region]
+        ).data
+        security_group = resources.get_or_create_security_group(
+            f"dstack-{instance_config.project_name}-default-security-group",
+            subnet.vcn_id,
+            self.config.compartment_id,
+            region.virtual_network_client,
+        )
+        resources.update_security_group_rules_for_runner_instances(
+            security_group.id, region.virtual_network_client
+        )
+
+        cloud_init_user_data = get_user_data(
+            authorized_keys=instance_config.get_public_keys(),
+            firewall_allow_from_subnets=[resources.VCN_CIDR],
+        )
+
+        display_name = generate_unique_instance_name(instance_config)
+        try:
+            instance = resources.launch_instance(
+                region=region,
+                availability_domain=availability_domain,
+                compartment_id=self.config.compartment_id,
+                subnet_id=subnet.id,
+                security_group_id=security_group.id,
+                display_name=display_name,
+                cloud_init_user_data=cloud_init_user_data,
+                shape=instance_offer.instance.name,
+                is_spot=instance_offer.instance.resources.spot,
+                disk_size_gb=round(instance_offer.instance.resources.disk.size_mib / 1024),
+                image_id=package.image_id,
+            )
+        except oci.exceptions.ServiceError as e:
+            if e.code in ("LimitExceeded", "QuotaExceeded") or "Out of host capacity" in e.message:
+                raise NoCapacityError(e.message)
+            raise
+
+        return JobProvisioningData(
+            backend=instance_offer.backend,
+            instance_type=instance_offer.instance,
+            instance_id=instance.id,
+            hostname=None,
+            internal_ip=None,
+            region=instance_offer.region,
+            availability_zone=availability_domain,
+            price=instance_offer.price,
+            username="ubuntu",
+            ssh_port=22,
+            dockerized=True,
+            ssh_proxy=None,
+            backend_data=None,
+        )
+
+    def update_provisioning_data(
+        self,
+        provisioning_data: JobProvisioningData,
+        project_ssh_public_key: str,
+        project_ssh_private_key: str,
+    ):
+        if vnic := resources.get_instance_vnic(
+            provisioning_data.instance_id,
+            self.regions[provisioning_data.region],
+            self.config.compartment_id,
+        ):
+            provisioning_data.hostname = vnic.public_ip
+            provisioning_data.internal_ip = vnic.private_ip
+
+
+def _supported_instances(offer: InstanceOffer) -> bool:
+    if "Flex" in offer.instance.name:
+        return False
+    return any(map(offer.instance.name.startswith, SUPPORTED_SHAPE_FAMILIES))