codemagic-cli-tools 0.48.2__tar.gz → 0.50.0__tar.gz

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codemagic-cli-tools
-Version: 0.48.2
+Version: 0.50.0
 Summary: CLI tools used in Codemagic builds
 Home-page: https://github.com/codemagic-ci-cd/cli-tools
 License: GPL-3.0-or-later

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codemagic-cli-tools"
-version = "0.48.2"
+version = "0.50.0"
 description = "CLI tools used in Codemagic builds"
 readme = "README.md"
 authors = [

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/__version__.py

@@ -1,5 +1,5 @@
 __title__ = "codemagic-cli-tools"
 __description__ = "CLI tools used in Codemagic builds"
-__version__ = '0.48.2'
+__version__ = '0.50.0'
 __url__ = "https://github.com/codemagic-ci-cd/cli-tools"
 __licence__ = "GNU General Public License v3.0"

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/__version__.py-e

@@ -1,5 +1,5 @@
 __title__ = "codemagic-cli-tools"
 __description__ = "CLI tools used in Codemagic builds"
-__version__ = "0.48.2.dev"
+__version__ = "0.50.0.dev"
 __url__ = "https://github.com/codemagic-ci-cd/cli-tools"
 __licence__ = "GNU General Public License v3.0"

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/apple/resources/bundle_id_capability.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Any
 from typing import Optional
 
 from .enums import CapabilityOptionKey
@@ -66,3 +67,13 @@ class BundleIdCapability(Resource):
     @dataclass
     class Relationships(Resource.Relationships):
         bundleId: Relationship
+
+    def _format_attribute_value(self, attribute_name: str, value: Any) -> Any:
+        if attribute_name == "capabilityType":
+            # In case we get an unknown capability type from API response, then this is stored as
+            # a runtime-created fallback enumeration `GracefulCapabilityType` which does not have
+            # the properties and methods that `CapabilityType` has.
+            if isinstance(self.attributes.capabilityType, CapabilityType):
+                return self.attributes.capabilityType.display_name
+            return CapabilityType.get_default_display_name(self.attributes.capabilityType.value)
+        return super()._format_attribute_value(attribute_name, value)

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/apple/resources/enums.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from typing import Tuple
 
 from codemagic.models.enums import ResourceEnum
@@ -78,30 +79,73 @@ class CapabilitySettingKey(ResourceEnum):
 
 
 class CapabilityType(ResourceEnum):
+    """
+    https://developer.apple.com/documentation/appstoreconnectapi/capabilitytype
+    """
+
     ACCESS_WIFI_INFORMATION = "ACCESS_WIFI_INFORMATION"
-    APP_GROUPS = "APP_GROUPS"
+    APPLE_ID_AUTH = "APPLE_ID_AUTH"
     APPLE_PAY = "APPLE_PAY"
+    APP_GROUPS = "APP_GROUPS"
     ASSOCIATED_DOMAINS = "ASSOCIATED_DOMAINS"
     AUTOFILL_CREDENTIAL_PROVIDER = "AUTOFILL_CREDENTIAL_PROVIDER"
     CLASSKIT = "CLASSKIT"
+    COREMEDIA_HLS_LOW_LATENCY = "COREMEDIA_HLS_LOW_LATENCY"
     DATA_PROTECTION = "DATA_PROTECTION"
     GAME_CENTER = "GAME_CENTER"
     HEALTHKIT = "HEALTHKIT"
     HOMEKIT = "HOMEKIT"
     HOT_SPOT = "HOT_SPOT"
     ICLOUD = "ICLOUD"
-    IN_APP_PURCHASE = "IN_APP_PURCHASE"
     INTER_APP_AUDIO = "INTER_APP_AUDIO"
+    IN_APP_PURCHASE = "IN_APP_PURCHASE"
     MAPS = "MAPS"
     MULTIPATH = "MULTIPATH"
+    NETWORK_CUSTOM_PROTOCOL = "NETWORK_CUSTOM_PROTOCOL"
     NETWORK_EXTENSIONS = "NETWORK_EXTENSIONS"
+    NETWORK_SLICING = "NETWORK_SLICING"
     NFC_TAG_READING = "NFC_TAG_READING"
     PERSONAL_VPN = "PERSONAL_VPN"
     PUSH_NOTIFICATIONS = "PUSH_NOTIFICATIONS"
     SIRIKIT = "SIRIKIT"
+    SYSTEM_EXTENSION_INSTALL = "SYSTEM_EXTENSION_INSTALL"
+    USER_MANAGEMENT = "USER_MANAGEMENT"
     WALLET = "WALLET"
     WIRELESS_ACCESSORY_CONFIGURATION = "WIRELESS_ACCESSORY_CONFIGURATION"
 
+    @classmethod
+    def from_display_name(cls, display_name: str) -> CapabilityType:
+        for capability_type in cls:
+            if capability_type.display_name == display_name:
+                return capability_type
+        raise ValueError("Unknown capability type", display_name)
+
+    @property
+    def display_name(self) -> str:
+        try:
+            return {
+                CapabilityType.ACCESS_WIFI_INFORMATION: "Access Wi-Fi Information",
+                CapabilityType.APPLE_ID_AUTH: "Sign In with Apple",
+                CapabilityType.COREMEDIA_HLS_LOW_LATENCY: "Low Latency HLS",
+                CapabilityType.HOT_SPOT: "Hotspot",
+                CapabilityType.ICLOUD: "iCloud",
+                CapabilityType.INTER_APP_AUDIO: "Inter-App Audio",
+                CapabilityType.IN_APP_PURCHASE: "In-App Purchase",
+                CapabilityType.NETWORK_CUSTOM_PROTOCOL: "Custom Network Protocol",
+                CapabilityType.NETWORK_SLICING: "5G Network Slicing",
+                CapabilityType.NFC_TAG_READING: "NFC Tag Reading",
+                CapabilityType.PERSONAL_VPN: "Personal VPN",
+                CapabilityType.SYSTEM_EXTENSION_INSTALL: "System Extension",
+            }[self]
+        except KeyError:
+            return self.get_default_display_name(self.value)
+
+    @classmethod
+    def get_default_display_name(cls, capability_type_value: str) -> str:
+        parts = capability_type_value.split("_")
+        title = " ".join(parts).title()
+        return re.sub(r"(kit)$", "Kit", title)
+
 
 class CertificateType(ResourceEnum):
     DEVELOPER_ID_APPLICATION = "DEVELOPER_ID_APPLICATION"

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/cli/__init__.py

@@ -1,3 +1,5 @@
+from .action import ActionDeprecationInfo
+from .action import action
 from .action_group import ActionGroup
 from .action_group import ActionGroupProperties
 from .argument import Argument
@@ -7,7 +9,6 @@ from .argument import EnvironmentArgumentValue
 from .argument import TypedCliArgument
 from .cli_app import CliApp
 from .cli_app import CliAppException
-from .cli_app import action
 from .cli_app import common_arguments
 from .cli_process import CliProcess
 from .cli_types import CommandArg

codemagic_cli_tools-0.50.0/src/codemagic/cli/action.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import dataclasses
+import sys
+from functools import wraps
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Optional
+from typing import TypeVar
+
+from .colors import Colors
+
+if TYPE_CHECKING:
+    from .action_group import ActionGroup
+    from .argument import Argument
+    from .cli_app import CliApp
+
+
+_Fn = TypeVar("_Fn", bound=Callable[..., object])
+
+
+@dataclasses.dataclass(frozen=True)
+class ActionDeprecationInfo:
+    alias: str
+    version: str
+
+    def get_message(self, replacement_action_name: str, *colors: Colors) -> str:
+        executable_name, _ = replacement_action_name.split(maxsplit=1)
+        deprecated_action_name = f"{executable_name} {self.alias}"
+        deprecation_message = (
+            f"Action `{deprecated_action_name}` was deprecated in version {self.version} "
+            f"and replaced by equivalent action `{replacement_action_name}`.\n"
+            f"Use `{replacement_action_name}` instead as `{deprecated_action_name}` "
+            f"is subject for removal in future releases."
+        )
+        return Colors.apply(deprecation_message, *colors)
+
+
+def action(
+    action_name: str,
+    *arguments: Argument,
+    action_group: Optional[ActionGroup] = None,
+    action_options: Optional[Dict[str, Any]] = None,
+    deprecation_info: Optional[ActionDeprecationInfo] = None,
+) -> Callable[[_Fn], _Fn]:
+    """
+    Decorator to mark that the method is usable from CLI
+    :param action_name: Name of the CLI parameter
+    :param arguments: CLI arguments that are required for this method to work
+    :param action_group: CLI argument group under which this action belongs
+    :param action_options: Meta information about the action to check whether some conditions are met
+    :param deprecation_info: Name and version pair describing the deprecated name of the action for
+                             backwards compatibility, and in which version it was deprecated.
+                             The action is registered on the root arguments parser with this name
+                             without explicit documentation.
+    """
+
+    # Ensure that each argument is used exactly once
+    unique_arguments = set()
+    function_cli_arguments = []
+    for argument in arguments:
+        argument_name = f"{argument.__class__.__name__}.{argument.name}"
+        if argument_name not in unique_arguments:
+            function_cli_arguments.append(argument)
+            unique_arguments.add(argument_name)
+
+    def decorator(func):
+        if func.__doc__ is None:
+            raise RuntimeError(f'Action "{action_name}" defined by {func} is not documented')
+        func.action_group = action_group
+        func.action_name = action_name
+        func.arguments = function_cli_arguments
+        func.is_cli_action = True
+        func.deprecation_info = deprecation_info
+        func.action_options = action_options or {}
+
+        @wraps(func)
+        def wrapper(self: CliApp, *args, **kwargs):
+            if deprecation_info and deprecation_info.alias in sys.argv:
+                _notify_deprecated_action_usage(self, action_name, action_group, deprecation_info)
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def _notify_deprecated_action_usage(
+    cli_app: CliApp,
+    action_name: str,
+    action_group: Optional[ActionGroup],
+    deprecation_info: ActionDeprecationInfo,
+):
+    executable = cli_app.get_executable_name()
+    name_parts = (executable, action_group.name if action_group else None, action_name)
+    full_action_name = " ".join(p for p in name_parts if p)
+    cli_app.echo(deprecation_info.get_message(full_action_name, Colors.YELLOW, Colors.BOLD))

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/cli/argument/__init__.py

@@ -1,4 +1,5 @@
 from .action_callable import ActionCallable
+from .action_callable import DeprecatedActionCallable
 from .argument import Argument
 from .argument_formatter import ArgumentFormatter
 from .argument_parser_builder import ArgumentParserBuilder

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/cli/argument/action_callable.py

@@ -9,6 +9,7 @@ from typing import Optional
 from typing import Sequence
 
 if TYPE_CHECKING:
+    from ..action import ActionDeprecationInfo
     from ..action_group import ActionGroup
     from .argument import Argument
 
@@ -19,6 +20,10 @@ class ActionCallable:
     arguments: Sequence[Argument]
     is_cli_action: bool
     action_options: Dict[str, Any]
-    deprecated_alias: Optional[str]
+    deprecation_info: Optional[ActionDeprecationInfo]
     __name__: str
     __call__: Callable
+
+
+class DeprecatedActionCallable(ActionCallable):
+    deprecation_info: ActionDeprecationInfo

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/cli/argument/argument_parser_builder.py

@@ -39,11 +39,16 @@ class ArgumentParserBuilder:
 
     def _create_action_parser(self, parent_parser: SubParsersAction, for_deprecated_alias: bool):
         if for_deprecated_alias:
-            if self._cli_action.deprecated_alias is None:
+            if self._cli_action.deprecation_info is None:
                 raise RuntimeError(f"Deprecated alias requested for {self._cli_action.action_name} without alias")
-            deprecation_message = Colors.YELLOW(Colors.BOLD(f"Deprecated alias for `{self._full_action_name}`."))
+
+            deprecation_message = self._cli_action.deprecation_info.get_message(
+                self._full_action_name,
+                Colors.YELLOW,
+                Colors.BOLD,
+            )
             return parent_parser.add_parser(
-                self._cli_action.deprecated_alias,
+                self._cli_action.deprecation_info.alias,
                 formatter_class=CliHelpFormatter,
                 description=f"{deprecation_message} {Colors.BOLD(self._cli_action.__doc__)}",
             )

{codemagic_cli_tools-0.48.2 → codemagic_cli_tools-0.50.0}/src/codemagic/cli/cli_app.py

@@ -12,7 +12,6 @@ import shlex
 import shutil
 import sys
 import time
-from functools import wraps
 from itertools import chain
 from typing import TYPE_CHECKING
 from typing import Any
@@ -36,6 +35,7 @@ from .action_group import ActionGroup
 from .argument import ActionCallable
 from .argument import Argument
 from .argument import ArgumentParserBuilder
+from .argument import DeprecatedActionCallable
 from .cli_help_formatter import CliHelpFormatter
 from .cli_process import CliProcess
 from .cli_types import CommandArg
@@ -173,7 +173,7 @@ class CliApp(metaclass=abc.ABCMeta):
         try:
             return cli_actions[action_key]
         except KeyError:
-            deprecated_cli_actions = {ac.deprecated_alias: ac for ac in self.iter_deprecated_cli_actions()}
+            deprecated_cli_actions = {ac.deprecation_info.alias: ac for ac in self.iter_deprecated_cli_actions()}
             return deprecated_cli_actions[action_key]
 
     def _invoke_action(self, args: argparse.Namespace):
@@ -320,9 +320,9 @@ class CliApp(metaclass=abc.ABCMeta):
         for class_action in self.iter_class_cli_actions(action_group=action_group):
             yield getattr(self, class_action.__name__)
 
-    def iter_deprecated_cli_actions(self) -> Iterable[ActionCallable]:
+    def iter_deprecated_cli_actions(self) -> Iterable[DeprecatedActionCallable]:
         for class_action in self.iter_class_cli_actions(include_all=True):
-            if class_action.deprecated_alias:
+            if class_action.deprecation_info:
                 yield getattr(self, class_action.__name__)
 
     @classmethod
@@ -385,12 +385,12 @@ class CliApp(metaclass=abc.ABCMeta):
         deprecated_action_parsers: SubParsersAction,
     ):
         ArgumentParserBuilder(cls, main_or_group_action, current_action_parsers).build()
-        if not main_or_group_action.deprecated_alias:
+        if not main_or_group_action.deprecation_info:
             return
 
         # Also register the deprecated alias
         ArgumentParserBuilder(cls, main_or_group_action, deprecated_action_parsers, for_deprecated_alias=True).build()
-        CliHelpFormatter.suppress_deprecated_action(main_or_group_action.deprecated_alias)
+        CliHelpFormatter.suppress_deprecated_action(main_or_group_action.deprecation_info.alias)
 
     def _obfuscate_command(
         self,
@@ -449,80 +449,11 @@ class CliApp(metaclass=abc.ABCMeta):
         ).execute(**execute_kwargs)
 
 
-_Fn = TypeVar("_Fn", bound=Callable[..., object])
-
-
-def action(
-    action_name: str,
-    *arguments: Argument,
-    action_group: Optional[ActionGroup] = None,
-    action_options: Optional[Dict[str, Any]] = None,
-    deprecated_alias: Optional[str] = None,
-) -> Callable[[_Fn], _Fn]:
-    """
-    Decorator to mark that the method is usable from CLI
-    :param action_name: Name of the CLI parameter
-    :param arguments: CLI arguments that are required for this method to work
-    :param action_group: CLI argument group under which this action belongs
-    :param action_options: Meta information about the action to check whether some conditions are met
-    :param deprecated_alias: Deprecated name of the action for backwards compatibility.
-                             The action is registered on the root arguments parser with this name
-                             without explicit documentation.
-    """
-
-    # Ensure that each argument is used exactly once
-    unique_arguments = set()
-    function_cli_arguments = []
-    for argument in arguments:
-        argument_name = f"{argument.__class__.__name__}.{argument.name}"
-        if argument_name not in unique_arguments:
-            function_cli_arguments.append(argument)
-            unique_arguments.add(argument_name)
-
-    def decorator(func):
-        if func.__doc__ is None:
-            raise RuntimeError(f'Action "{action_name}" defined by {func} is not documented')
-        func.action_group = action_group
-        func.action_name = action_name
-        func.arguments = function_cli_arguments
-        func.is_cli_action = True
-        func.deprecated_alias = deprecated_alias
-        func.action_options = action_options or {}
-
-        @wraps(func)
-        def wrapper(self: CliApp, *args, **kwargs):
-            if deprecated_alias and deprecated_alias in sys.argv:
-                _notify_deprecated_action_usage(self, action_name, action_group, deprecated_alias)
-            return func(self, *args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def _notify_deprecated_action_usage(
-    cli_app: CliApp,
-    action_name: str,
-    action_group: Optional[ActionGroup],
-    deprecated_alias: str,
-):
-    executable = cli_app.get_executable_name()
-    name_parts = (executable, action_group.name if action_group else None, action_name)
-    full_action_name = " ".join(p for p in name_parts if p)
-    deprecated_action_name = f"{executable} {deprecated_alias}"
-    deprecation_message = (
-        f"Using `{deprecated_action_name}` is deprecated and replaced by equivalent action `{full_action_name}`.\n"
-        f"Use `{full_action_name}` instead as `{deprecated_action_name}` is subject for removal in future releases.\n"
-    )
-    cli_app.echo(Colors.apply(deprecation_message, Colors.YELLOW, Colors.BOLD))
-
-
 _CliApp = TypeVar("_CliApp", bound=Type[CliApp])
 
 
 def common_arguments(*class_arguments: Argument) -> Callable[[_CliApp], _CliApp]:
     """
-    Decorator to mark that the method is usable from CLI
     :param class_arguments: CLI arguments that are required to initialize the class
     """
 

codemagic_cli_tools-0.50.0/src/codemagic/tools/app_store_connect/__init__.py

@@ -0,0 +1 @@
+from .app_store_connect import AppStoreConnect

codemagic_cli_tools-0.50.0/src/codemagic/tools/app_store_connect/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    from .app_store_connect import AppStoreConnect
+
+    AppStoreConnect.invoke_cli()

{codemagic_cli_tools-0.48.2/src/codemagic/tools/_app_store_connect → codemagic_cli_tools-0.50.0/src/codemagic/tools/app_store_connect}/abstract_base_action.py

@@ -24,20 +24,32 @@ from codemagic.apple.resources import BetaBuildLocalization
 from codemagic.apple.resources import BetaReviewState
 from codemagic.apple.resources import Build
 from codemagic.apple.resources import BuildProcessingState
+from codemagic.apple.resources import BundleId
+from codemagic.apple.resources import BundleIdPlatform
+from codemagic.apple.resources import CertificateType
+from codemagic.apple.resources import Device
+from codemagic.apple.resources import DeviceStatus
 from codemagic.apple.resources import Locale
 from codemagic.apple.resources import Platform
+from codemagic.apple.resources import Profile
+from codemagic.apple.resources import ProfileState
+from codemagic.apple.resources import ProfileType
 from codemagic.apple.resources import ReleaseType
 from codemagic.apple.resources import ResourceId
 from codemagic.apple.resources import ReviewSubmission
 from codemagic.apple.resources import ReviewSubmissionItem
 from codemagic.apple.resources import ReviewSubmissionState
+from codemagic.apple.resources import SigningCertificate
 from codemagic.mixins import PathFinderMixin
+from codemagic.models import PrivateKey
 
 from .arguments import AppStoreVersionInfo
 from .arguments import AppStoreVersionLocalizationInfo
 from .arguments import BetaBuildInfo
+from .arguments import CertificateArgument
 from .arguments import Types
-from .resource_manager_mixin import ResourceManagerMixin
+from .mixins import ResourceManagerMixin
+from .mixins import SigningFileSaverMixin
 from .resource_printer import ResourcePrinter
 
 AppStoreVersionLocalizationInfos = Union[
@@ -46,7 +58,12 @@ AppStoreVersionLocalizationInfos = Union[
 ]
 
 
-class AbstractBaseAction(ResourceManagerMixin, PathFinderMixin, metaclass=ABCMeta):
+class AbstractBaseAction(
+    ResourceManagerMixin,
+    SigningFileSaverMixin,
+    PathFinderMixin,
+    metaclass=ABCMeta,
+):
     logger: logging.Logger
     profiles_directory: pathlib.Path
     certificates_directory: pathlib.Path
@@ -55,6 +72,21 @@ class AbstractBaseAction(ResourceManagerMixin, PathFinderMixin, metaclass=ABCMet
     _issuer_id: Optional[IssuerId]
     _private_key: Optional[str]
 
+    @staticmethod
+    def _get_certificate_key(
+        certificate_key: Optional[Union[PrivateKey, Types.CertificateKeyArgument]] = None,
+        certificate_key_password: Optional[Types.CertificateKeyPasswordArgument] = None,
+    ) -> Optional[PrivateKey]:
+        if isinstance(certificate_key, PrivateKey):
+            return certificate_key
+        password = certificate_key_password.value if certificate_key_password else None
+        if certificate_key is not None:
+            try:
+                return PrivateKey.from_buffer(certificate_key.value, password)
+            except ValueError:
+                CertificateArgument.PRIVATE_KEY.raise_argument_error("Not a valid certificate private key")
+        return None
+
     # Define signatures for self-reference to other action groups
 
     @property
@@ -186,6 +218,51 @@ class AbstractBaseAction(ResourceManagerMixin, PathFinderMixin, metaclass=ABCMet
         _ = BetaBuildLocalizationsActionGroup.create_beta_build_localization  # Implementation
         raise NotImplementedError()
 
+    @abstractmethod
+    def create_bundle_id(
+        self,
+        bundle_id_identifier: str,
+        bundle_id_name: Optional[str] = None,
+        platform: BundleIdPlatform = BundleIdPlatform.IOS,
+        should_print: bool = True,
+    ) -> BundleId:
+        from .action_groups import BundleIdsActionGroup
+
+        _ = BundleIdsActionGroup.create_bundle_id  # Implementation
+        raise NotImplementedError()
+
+    @abstractmethod
+    def create_certificate(
+        self,
+        certificate_type: CertificateType = CertificateType.IOS_DEVELOPMENT,
+        certificate_key: Optional[Union[PrivateKey, Types.CertificateKeyArgument]] = None,
+        certificate_key_password: Optional[Types.CertificateKeyPasswordArgument] = None,
+        p12_container_password: str = "",
+        p12_container_save_path: Optional[pathlib.Path] = None,
+        save: bool = False,
+        should_print: bool = True,
+    ) -> SigningCertificate:
+        from .action_groups import CertificatesActionGroup
+
+        _ = CertificatesActionGroup.create_certificate  # Implementation
+        raise NotImplementedError()
+
+    @abstractmethod
+    def create_profile(
+        self,
+        bundle_id_resource_id: ResourceId,
+        certificate_resource_ids: Sequence[ResourceId],
+        device_resource_ids: Optional[Sequence[ResourceId]] = None,
+        profile_type: ProfileType = ProfileType.IOS_APP_DEVELOPMENT,
+        profile_name: Optional[str] = None,
+        save: bool = False,
+        should_print: bool = True,
+    ) -> Profile:
+        from .action_groups import ProfilesActionGroup
+
+        _ = ProfilesActionGroup.create_profile  # Implementation
+        raise NotImplementedError()
+
     @abstractmethod
     def create_review_submission(
         self,
@@ -260,6 +337,17 @@ class AbstractBaseAction(ResourceManagerMixin, PathFinderMixin, metaclass=ABCMet
         _ = AppsActionGroup.cancel_review_submissions  # Implementation
         raise NotImplementedError()
 
+    @abstractmethod
+    def get_bundle_id(
+        self,
+        bundle_id_resource_id: ResourceId,
+        should_print: bool = True,
+    ) -> BundleId:
+        from .action_groups import BundleIdsActionGroup
+
+        _ = BundleIdsActionGroup.get_bundle_id  # Implementation
+        raise NotImplementedError()
+
     @abstractmethod
     def list_app_store_version_localizations(
         self,
@@ -303,9 +391,69 @@ class AbstractBaseAction(ResourceManagerMixin, PathFinderMixin, metaclass=ABCMet
         build_version_number: Optional[int] = None,
         should_print: bool = True,
     ) -> List[Build]:
-        from ..app_store_connect import AppStoreConnect
+        from .action_groups import BuildsActionGroup
+
+        _ = BuildsActionGroup.list_builds  # Implementation
+        raise NotImplementedError()
+
+    @abstractmethod
+    def list_bundle_ids(
+        self,
+        bundle_id_identifier: Optional[str] = None,
+        bundle_id_name: Optional[str] = None,
+        platform: Optional[BundleIdPlatform] = None,
+        bundle_id_identifier_strict_match: bool = False,
+        should_print: bool = True,
+    ) -> List[BundleId]:
+        from .action_groups import BundleIdsActionGroup
+
+        _ = BundleIdsActionGroup.list_bundle_ids  # Implementation
+        raise NotImplementedError()
+
+    @abstractmethod
+    def list_bundle_id_profiles(
+        self,
+        bundle_id_resource_ids: Sequence[ResourceId],
+        profile_type: Optional[ProfileType] = None,
+        profile_state: Optional[ProfileState] = None,
+        profile_name: Optional[str] = None,
+        save: bool = False,
+        should_print: bool = True,
+    ) -> List[Profile]:
+        from .action_groups import BundleIdsActionGroup
+
+        _ = BundleIdsActionGroup.list_bundle_id_profiles  # Implementation
+        raise NotImplementedError()
+
+    @abstractmethod
+    def list_certificates(
+        self,
+        certificate_types: Optional[Union[CertificateType, Sequence[CertificateType]]] = None,
+        profile_type: Optional[ProfileType] = None,
+        display_name: Optional[str] = None,
+        certificate_key: Optional[Union[PrivateKey, Types.CertificateKeyArgument]] = None,
+        certificate_key_password: Optional[Types.CertificateKeyPasswordArgument] = None,
+        p12_container_password: str = "",
+        save: bool = False,
+        should_print: bool = True,
+        **_deprecated_kwargs,
+    ) -> List[SigningCertificate]:
+        from .action_groups import CertificatesActionGroup
+
+        _ = CertificatesActionGroup.list_certificates  # Implementation
+        raise NotImplementedError()
+
+    @abstractmethod
+    def list_devices(
+        self,
+        platform: Optional[BundleIdPlatform] = None,
+        device_name: Optional[str] = None,
+        device_status: Optional[DeviceStatus] = None,
+        should_print: bool = True,
+    ) -> List[Device]:
+        from .action_groups import DevicesActionGroup
 
-        _ = AppStoreConnect.list_builds  # Implementation
+        _ = DevicesActionGroup.list_devices  # Implementation
         raise NotImplementedError()
 
     @abstractmethod