catalystwan 0.40.2.dev1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

catalystwan/api/builders/feature_profiles/report.py

@@ -1,137 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-import functools
-from typing import Any, List, Optional, Tuple, Union
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, Field
-from requests import PreparedRequest, Request, Response
-
-from catalystwan.exceptions import ManagerErrorInfo, ManagerHTTPError
-from catalystwan.models.configuration.feature_profile.parcel import AnyParcel
-
-
-def handle_build_report(func):
-    """Wrapper to make creating report simple and keep it DRY."""
-
-    @functools.wraps(func)
-    def wrapper(self, profile_uuid: UUID, parcel: AnyParcel, *args, **kwargs) -> Optional[UUID]:
-        try:
-            uuid = func(self, profile_uuid, parcel, *args, **kwargs)
-            self.build_report.add_created_parcel(parcel.parcel_name, uuid)
-            return uuid
-        except ManagerHTTPError as e:
-            self.build_report.add_failed_parcel(
-                parcel_name=parcel.parcel_name,
-                parcel_type=parcel._get_parcel_type(),
-                error=e,
-            )
-            return None
-
-    return wrapper
-
-
-class FailedRequestDetails(BaseModel):
-    method: str
-    url: str
-    body: str
-
-    @classmethod
-    def from_request(cls, request: Union[Request, PreparedRequest, Any]) -> "FailedRequestDetails":
-        if isinstance(request, (Request, PreparedRequest)):
-            return cls(
-                method=str(request.method),
-                url=str(request.url),
-                body=str(request.body if hasattr(request, "body") else ""),
-            )
-        return cls.as_empty()
-
-    @classmethod
-    def as_empty(cls) -> "FailedRequestDetails":
-        return cls(method="", url="", body="")
-
-
-class ResponseDetails(BaseModel):
-    status_code: int
-    reason: str
-
-    @classmethod
-    def from_response(cls, response: Union[Response, Any]) -> "ResponseDetails":
-        if isinstance(response, Response):
-            return cls(status_code=response.status_code, reason=response.reason)
-        return cls.as_empty()
-
-    @classmethod
-    def as_empty(cls) -> "ResponseDetails":
-        return cls(status_code=-1, reason="")
-
-
-class FailedParcel(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    parcel_name: str = Field(serialization_alias="parcelName", validation_alias="parcelName")
-    parcel_type: str = Field(serialization_alias="parcelType", validation_alias="parcelType")
-    error_info: Union[ManagerErrorInfo, str] = Field(serialization_alias="errorInfo", validation_alias="errorInfo")
-    request_details: Optional[FailedRequestDetails] = Field(
-        default=None, serialization_alias="requestDetails", validation_alias="requestDetails"
-    )
-    response_details: Optional[ResponseDetails] = Field(
-        default=None, serialization_alias="responseDetails", validation_alias="responseDetails"
-    )
-
-    @classmethod
-    def from_error(
-        cls,
-        parcel_name: str,
-        parcel_type: str,
-        error: ManagerHTTPError,
-    ):
-        return cls(
-            parcel_name=parcel_name,
-            parcel_type=parcel_type,
-            error_info=error.info,
-            request_details=FailedRequestDetails.from_request(error.request),
-            response_details=ResponseDetails.from_response(error.response),
-        )
-
-
-class FeatureProfileBuildReport(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    profile_name: str = Field(serialization_alias="profileName", validation_alias="profileName")
-    profile_uuid: UUID = Field(serialization_alias="profileUuid", validation_alias="profileUuid")
-    created_parcels: List[Tuple[str, UUID]] = Field(
-        default_factory=list, serialization_alias="createdParcels", validation_alias="createdParcels"
-    )
-    failed_parcels: List[FailedParcel] = Field(
-        default_factory=list, serialization_alias="failedParcels", validation_alias="failedParcels"
-    )
-
-    def add_created_parcel(self, parcel_name: str, parcel_uuid: UUID) -> None:
-        self.created_parcels.append((parcel_name, parcel_uuid))
-
-    def add_failed_parcel(
-        self,
-        parcel_name: str,
-        parcel_type: str,
-        error: ManagerHTTPError,
-    ) -> None:
-        self.failed_parcels.append(
-            FailedParcel.from_error(
-                parcel_name=parcel_name,
-                parcel_type=parcel_type,
-                error=error,
-            )
-        )
-
-
-def handle_build_report_for_failed_subparcel(
-    build_report: FeatureProfileBuildReport, parent: AnyParcel, subparcel: AnyParcel
-) -> None:
-    parent_failed_to_create_message = (
-        f"Parent parcel: {parent.parcel_name} failed to create. This subparcel is dependent on it."
-    )
-    build_report.failed_parcels.append(
-        FailedParcel(
-            parcel_name=subparcel.parcel_name,
-            parcel_type=subparcel._get_parcel_type(),
-            error_info=parent_failed_to_create_message,
-        ),
-    )

catalystwan/api/builders/feature_profiles/service.py

@@ -1,213 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
-
-import logging
-from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
-from uuid import UUID, uuid4
-
-from pydantic import Field
-from typing_extensions import Annotated
-
-from catalystwan.api.builders.feature_profiles.report import (
-    FeatureProfileBuildReport,
-    handle_build_report,
-    handle_build_report_for_failed_subparcel,
-)
-from catalystwan.api.feature_profile_api import ServiceFeatureProfileAPI
-from catalystwan.endpoints.configuration.feature_profile.sdwan.service import ServiceFeatureProfile
-from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
-from catalystwan.models.configuration.feature_profile.parcel import ParcelAssociationPayload
-from catalystwan.models.configuration.feature_profile.sdwan.routing import AnyRoutingParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service import (
-    AnyServiceParcel,
-    AppqoeParcel,
-    InterfaceEthernetParcel,
-    InterfaceGreParcel,
-    InterfaceIpsecParcel,
-    InterfaceSviParcel,
-    LanVpnDhcpServerParcel,
-    LanVpnParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.multicast import MulticastParcel
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-IndependedParcels = Annotated[Union[AppqoeParcel, LanVpnDhcpServerParcel], Field(discriminator="type_")]
-DependedVpnSubparcels = Annotated[
-    Union[InterfaceGreParcel, InterfaceSviParcel, InterfaceEthernetParcel, InterfaceIpsecParcel, MulticastParcel],
-    Field(discriminator="type_"),
-]
-
-
-class ServiceFeatureProfileBuilder:
-    """
-    A class for building service feature profiles.
-    """
-
-    def __init__(self, session: ManagerSession):
-        """
-        Initialize a new instance of the Service class.
-
-        Args:
-            session (ManagerSession): The ManagerSession object used for API communication.
-            profile_uuid (UUID): The UUID of the profile.
-        """
-        self._profile: FeatureProfileCreationPayload
-        self._api = ServiceFeatureProfileAPI(session)
-        self._endpoints = ServiceFeatureProfile(session)
-        self._independent_items: List[IndependedParcels] = []
-        self._independent_items_vpns: Dict[UUID, LanVpnParcel] = {}
-        self._dependent_items_on_vpns: Dict[UUID, List[DependedVpnSubparcels]] = defaultdict(list)
-        self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
-        self._interfaces_with_attached_dhcp_server: Dict[str, LanVpnDhcpServerParcel] = {}
-
-    def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
-        """
-        Adds a name and description to the feature profile.
-
-        Args:
-            name (str): The name of the feature profile.
-            description (str): The description of the feature profile.
-
-        Returns:
-            None
-        """
-        self._profile = feature_profile
-
-    def add_parcel(self, parcel: IndependedParcels) -> None:
-        """
-        Adds an independent parcel to the builder.
-
-        Args:
-            parcel (IndependedParcels): The independent parcel to add.
-
-        Returns:
-            None
-        """
-        self._independent_items.append(parcel)
-
-    def add_parcel_vpn(self, parcel: LanVpnParcel) -> UUID:
-        """
-        Adds a VPN parcel to the builder.
-
-        Args:
-            parcel (LanVpnParcel): The VPN parcel to add.
-
-        Returns:
-            UUID: The UUID tag of the added VPN parcel.
-        """
-        vpn_tag = uuid4()
-        logger.debug(f"Adding VPN parcel {parcel.parcel_name} with tag {vpn_tag}")
-        self._independent_items_vpns[vpn_tag] = parcel
-        return vpn_tag
-
-    def add_parcel_routing_attached(self, vpn_tag: UUID, parcel: AnyRoutingParcel) -> None:
-        """
-        Adds a routing parcel to the builder.
-
-        Args:
-            vpn_tag (UUID): The UUID of the VPN.
-            parcel (AnyServiceParcel): The routing parcel to add.
-
-        Returns:
-            None
-        """
-        logger.debug(f"Adding routing parcel {parcel.parcel_name} to VPN {vpn_tag}")
-        self._dependent_routing_items_on_vpns[vpn_tag].append(parcel)
-
-    def add_parcel_vpn_subparcel(self, vpn_tag: UUID, parcel: DependedVpnSubparcels) -> None:
-        """
-        Adds an subparcel parcel dependent on a VPN to the builder.
-
-        Args:
-            vpn_tag (UUID): The UUID of the VPN.
-            parcel (DependedVpnSubparcels): The interface parcel to add.
-
-        Returns:
-            None
-        """
-        logger.debug(f"Adding subparcel parcel {parcel.parcel_name} to VPN {vpn_tag}")
-        self._dependent_items_on_vpns[vpn_tag].append(parcel)
-
-    def add_parcel_dhcp_server(self, interface_parcel_name: str, parcel: LanVpnDhcpServerParcel) -> None:
-        """
-        Adds a DHCP server parcel to the builder.
-
-        Args:
-            interface_tag (UUID): The UUID of the interface.
-            parcel (LanVpnDhcpServerParcel): The DHCP server parcel to add.
-
-        Returns:
-            UUID: The UUID tag of the added DHCP server parcel.
-        """
-        logger.debug(f"Adding DHCP server parcel {parcel.parcel_name} to interface {interface_parcel_name}")
-        self._interfaces_with_attached_dhcp_server[interface_parcel_name] = parcel
-
-    def build(self) -> FeatureProfileBuildReport:
-        """
-        Builds the feature profile by creating parcels for independent items,
-        VPNs, and sub-parcels dependent on VPNs.
-
-        Returns:
-            Service feature profile UUID
-        """
-        profile_uuid = self._endpoints.create_sdwan_service_feature_profile(self._profile).id
-        self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
-        for parcel in self._independent_items:
-            self._create_parcel(profile_uuid, parcel)
-        for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
-            vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
-
-            for routing_parcel in self._dependent_routing_items_on_vpns[vpn_tag]:
-                if vpn_uuid is None:
-                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, routing_parcel)
-                else:
-                    routing_uuid = self._create_parcel(profile_uuid, routing_parcel)
-                    if not routing_uuid:
-                        continue
-                    self._endpoints.associate_with_vpn(
-                        profile_uuid,
-                        vpn_uuid,
-                        routing_parcel._get_parcel_type(),
-                        payload=ParcelAssociationPayload(parcel_id=routing_uuid),
-                    )
-
-            for sub_parcel in self._dependent_items_on_vpns[vpn_tag]:
-                if vpn_uuid is None:
-                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, sub_parcel)
-                else:
-                    parcel_uuid = self._create_parcel(profile_uuid, sub_parcel, vpn_uuid)
-                    dhcp_server = self._interfaces_with_attached_dhcp_server.get(sub_parcel.parcel_name)
-
-                    if dhcp_server is None:
-                        # The interface does not have a DHCP server attached
-                        continue
-
-                    if parcel_uuid is None:
-                        # The parent could not be created
-                        handle_build_report_for_failed_subparcel(self.build_report, sub_parcel, dhcp_server)
-                        continue
-
-                    dhcp_server_uuid = self._create_parcel(profile_uuid, dhcp_server)
-
-                    if dhcp_server_uuid is None:
-                        # The DHCP server could not be created
-                        continue
-
-                    self._endpoints.associate_dhcp_server_with_vpn_interface(
-                        profile_uuid=profile_uuid,
-                        vpn_uuid=vpn_uuid,
-                        interface_parcel_type=sub_parcel._get_parcel_type().replace("lan/vpn/", ""),
-                        interface_uuid=parcel_uuid,
-                        payload=ParcelAssociationPayload(parcel_id=dhcp_server_uuid),
-                    )
-
-        return self.build_report
-
-    @handle_build_report
-    def _create_parcel(self, profile_uuid: UUID, parcel: AnyServiceParcel, vpn_uuid: Optional[None] = None) -> UUID:
-        return self._api.create_parcel(profile_uuid, parcel, vpn_uuid).id

catalystwan/api/builders/feature_profiles/system.py

@@ -1,80 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, List
-from uuid import UUID
-
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
-from catalystwan.api.feature_profile_api import SystemFeatureProfileAPI
-from catalystwan.endpoints.configuration.feature_profile.sdwan.system import SystemFeatureProfile
-from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
-from catalystwan.models.configuration.feature_profile.sdwan.system import AnySystemParcel
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class SystemFeatureProfileBuilder:
-    """
-    A class for building system feature profiles.
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        """
-        Initialize a new instance of the Service class.
-
-        Args:
-            session (ManagerSession): The ManagerSession object used for API communication.
-            profile_uuid (UUID): The UUID of the profile.
-        """
-
-        self._profile: FeatureProfileCreationPayload
-        self._api = SystemFeatureProfileAPI(session)
-        self._endpoints = SystemFeatureProfile(session)
-        self._independent_items: List[AnySystemParcel] = []
-
-    def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
-        """
-        Adds a name and description to the feature profile.
-
-        Args:
-            name (str): The name of the feature profile.
-            description (str): The description of the feature profile.
-
-        Returns:
-            None
-        """
-        self._profile = feature_profile
-
-    def add_parcel(self, parcel: AnySystemParcel) -> None:
-        """
-        Adds a parcel to the feature profile.
-
-        Args:
-            parcel (AnySystemParcel): The parcel to add.
-
-        Returns:
-            None
-        """
-        self._independent_items.append(parcel)
-
-    def build(self) -> FeatureProfileBuildReport:
-        """
-        Builds the feature profile.
-
-        Returns:
-            UUID: The UUID of the created feature profile.
-        """
-
-        profile_uuid = self._endpoints.create_sdwan_system_feature_profile(self._profile).id
-        self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
-        for parcel in self._independent_items:
-            self._create_parcels(profile_uuid, parcel)
-        return self.build_report
-
-    @handle_build_report
-    def _create_parcels(self, profile_uuid: UUID, parcel: AnySystemParcel) -> UUID:
-        return self._api.create_parcel(profile_uuid, parcel).id

catalystwan/api/builders/feature_profiles/transport.py

@@ -1,214 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
-
-import logging
-from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
-from uuid import UUID, uuid4
-
-from catalystwan.api.builders.feature_profiles.report import (
-    FeatureProfileBuildReport,
-    handle_build_report,
-    handle_build_report_for_failed_subparcel,
-)
-from catalystwan.api.feature_profile_api import TransportFeatureProfileAPI
-from catalystwan.endpoints.configuration.feature_profile.sdwan.transport import TransportFeatureProfile
-from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
-from catalystwan.models.configuration.feature_profile.parcel import ParcelAssociationPayload
-from catalystwan.models.configuration.feature_profile.sdwan.routing import AnyRoutingParcel
-from catalystwan.models.configuration.feature_profile.sdwan.transport import (
-    AnyTransportParcel,
-    AnyTransportSuperParcel,
-    AnyTransportVpnParcel,
-    AnyTransportVpnSubParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_controller import (
-    CellularControllerParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_profile import CellularProfileParcel
-from catalystwan.models.configuration.feature_profile.sdwan.transport.gps import GpsParcel
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class TransportAndManagementProfileBuilder:
-    """
-    A class for building system feature profiles.
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        """
-        Initialize a new instance of the Service class.
-
-        Args:
-            session (ManagerSession): The ManagerSession object used for API communication.
-            profile_uuid (UUID): The UUID of the profile.
-        """
-        self._profile: FeatureProfileCreationPayload
-        self._api = TransportFeatureProfileAPI(session)
-        self._endpoints = TransportFeatureProfile(session)
-        self._independent_items: List[AnyTransportSuperParcel] = []
-        self._independent_items_vpns: Dict[UUID, AnyTransportVpnParcel] = {}
-        self._independent_items_cellular_controllers: Dict[UUID, CellularControllerParcel] = {}
-        self._dependent_items_on_vpns: Dict[UUID, List[AnyTransportVpnSubParcel]] = defaultdict(list)
-        self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
-        self._dependent_items_on_cellular_controllers: Dict[
-            UUID, List[Union[CellularProfileParcel, GpsParcel]]
-        ] = defaultdict(list)
-
-    def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
-        """
-        Adds a name and description to the feature profile.
-
-        Args:
-            name (str): The name of the feature profile.
-            description (str): The description of the feature profile.
-
-        Returns:
-            None
-        """
-        self._profile = feature_profile
-
-    def add_parcel(self, parcel: AnyTransportSuperParcel) -> None:
-        """
-        Adds a parcel to the feature profile.
-
-        Args:
-            parcel (AnyTransportSuperParcel): The parcel to add.
-
-        Returns:
-            None
-        """
-        self._independent_items.append(parcel)
-
-    def add_parcel_routing_attached(self, vpn_tag: UUID, parcel: AnyRoutingParcel) -> None:
-        """
-        Adds a routing parcel to the feature profile.
-
-        Args:
-            parcel (AnyRoutingParcel): The parcel to add.
-
-        Returns:
-            None
-        """
-        logger.debug(f"Attaching routing {parcel.parcel_name} with to VPN with tag {vpn_tag}")
-        self._dependent_routing_items_on_vpns[vpn_tag].append(parcel)
-
-    def add_parcel_vpn(self, parcel: AnyTransportVpnParcel) -> UUID:
-        """
-        Adds a VPN parcel to the builder.
-
-        Args:
-            parcel (LanVpnParcel): The VPN parcel to add.
-
-        Returns:
-            UUID: The UUID tag of the added VPN parcel.
-        """
-        vpn_tag = uuid4()
-        logger.debug(f"Adding VPN parcel {parcel.parcel_name} with tag {vpn_tag}")
-        self._independent_items_vpns[vpn_tag] = parcel
-        return vpn_tag
-
-    def add_parcel_cellular_controller(self, parcel: CellularControllerParcel) -> UUID:
-        """
-        Adds a cellular controller parcel to the builder.
-
-        Args:
-            parcel (CellularControllerParcel): The cellular controller parcel to add.
-
-        Returns:
-            UUID: The UUID tag of the added cellular controller parcel.
-        """
-        cellular_controller_tag = uuid4()
-        logger.debug(f"Adding cellular controller parcel {parcel.parcel_name} with tag {cellular_controller_tag}")
-        self._independent_items_cellular_controllers[cellular_controller_tag] = parcel
-        return cellular_controller_tag
-
-    def add_cellular_controller_subparcel(
-        self, cellular_controller_tag: UUID, parcel: Union[CellularProfileParcel, GpsParcel]
-    ) -> None:
-        """
-        Adds a subparcel to the cellular controller parcel.
-
-        Args:
-            cellular_controller_tag (UUID): The UUID of the cellular controller.
-            parcel (Union[CellularProfileParcel, GpsParcel]): The subparcel to add.
-
-        Returns:
-            None
-        """
-        self._dependent_items_on_cellular_controllers[cellular_controller_tag].append(parcel)
-
-    def add_vpn_subparcel(self, vpn_tag: UUID, parcel: AnyTransportVpnSubParcel) -> None:
-        """
-        Adds a parcel to the feature profile.
-
-        Args:
-            parcel (AnyTransportVpnSubParcel): The parcel to add.
-
-        Returns:
-            None
-        """
-        self._dependent_items_on_vpns[vpn_tag].append(parcel)
-
-    def build(self) -> FeatureProfileBuildReport:
-        """
-        Builds the feature profile.
-
-        Returns:
-            UUID: The UUID of the created feature profile.
-        """
-
-        profile_uuid = self._endpoints.create_transport_feature_profile(self._profile).id
-        self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
-        for parcel in self._independent_items:
-            self._create_parcel(profile_uuid, parcel)
-
-        for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
-            vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
-            for vpn_subparcel in self._dependent_items_on_vpns[vpn_tag]:
-                if vpn_uuid is None:
-                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, vpn_subparcel)
-                else:
-                    self._create_parcel(profile_uuid, vpn_subparcel, vpn_uuid)
-
-            for routing_parcel in self._dependent_routing_items_on_vpns[vpn_tag]:
-                if vpn_uuid is None:
-                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, routing_parcel)
-                else:
-                    routing_uuid = self._create_parcel(profile_uuid, routing_parcel)
-                    if not routing_uuid:
-                        continue
-                    self._endpoints.associate_with_vpn(
-                        profile_uuid,
-                        vpn_uuid,
-                        routing_parcel._get_parcel_type(),
-                        payload=ParcelAssociationPayload(parcel_id=routing_uuid),
-                    )
-
-        for cellular_controller_tag, cellular_controller_parcel in self._independent_items_cellular_controllers.items():
-            controller_uuid = self._create_parcel(profile_uuid, cellular_controller_parcel)
-            for cellular_subparcel in self._dependent_items_on_cellular_controllers[cellular_controller_tag]:
-                if controller_uuid is None:
-                    handle_build_report_for_failed_subparcel(
-                        self.build_report, cellular_controller_parcel, cellular_subparcel
-                    )
-                else:
-                    parcel_uuid = self._create_parcel(profile_uuid, cellular_subparcel)
-                    if not parcel_uuid:
-                        continue
-                    self._endpoints.associate_with_cellular_controller(
-                        profile_uuid,
-                        controller_uuid,
-                        cellular_subparcel._get_parcel_type(),
-                        ParcelAssociationPayload(parcel_id=parcel_uuid),
-                    )
-
-        return self.build_report
-
-    @handle_build_report
-    def _create_parcel(self, profile_uuid: UUID, parcel: AnyTransportParcel, vpn_uuid: Optional[None] = None) -> UUID:
-        return self._api.create_parcel(profile_uuid, parcel, vpn_uuid).id