codemagic-cli-tools 0.40.5__tar.gz → 0.42.0__tar.gz

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codemagic-cli-tools
-Version: 0.40.5
+Version: 0.42.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.40.5 → codemagic_cli_tools-0.42.0}/pyproject.toml

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

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/__version__.py

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

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/__version__.py-e

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

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/cli/argument/typed_cli_argument.py

@@ -85,8 +85,8 @@ class TypedCliArgument(Generic[T], metaclass=TypedCliArgumentMeta):
 
     def __init__(self, raw_value: str, from_environment=False):
         self._raw_value = raw_value
-        self.value: T = self._parse_value()
         self._from_environment = from_environment
+        self.value: T = self._parse_value()
 
     @classmethod
     def resolve_value(cls, argument_instance: Optional[Union[T, TypedCliArgument]]) -> T:
@@ -119,10 +119,9 @@ class TypedCliArgument(Generic[T], metaclass=TypedCliArgumentMeta):
     def _is_valid(cls, value: T) -> bool:
         return bool(value)
 
-    @classmethod
-    def _apply_type(cls, non_typed_value: str) -> T:
-        value = cls.argument_type(non_typed_value)
-        if not cls._is_valid(value):
+    def _apply_type(self, non_typed_value: str) -> T:
+        value = self.argument_type(non_typed_value)  # type: ignore
+        if not self._is_valid(value):
             raise argparse.ArgumentTypeError(f'Provided value "{non_typed_value}" is not valid')
         return value
 
@@ -239,4 +238,4 @@ class EnvironmentArgumentValue(TypedCliArgument[T], metaclass=TypedCliArgumentMe
         return self._raw_value
 
     def __repr__(self):
-        return self._raw_value
+        return f"{self.__class__.__name__}({self._raw_value!r})"

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/models/xcodebuild.py

@@ -176,7 +176,7 @@ class Xcodebuild(RunningCliAppMixin):
 
     def _construct_test_command(
         self,
-        sdk: str,
+        sdk: Optional[str],
         simulators: List[Simulator],
         only_testing: Optional[str],
         enable_code_coverage: bool,
@@ -188,6 +188,7 @@ class Xcodebuild(RunningCliAppMixin):
         max_devices_flag = "-maximum-concurrent-test-device-destinations"
         max_sims_flag = "-maximum-concurrent-test-simulator-destinations"
 
+        sdk_args = ["-sdk", sdk] if sdk else []
         destinations_args = [["-destination", f"id={s.udid}"] for s in simulators]
         only_testing_args = ["-only-testing", only_testing] if only_testing else []
         max_devices_args = [max_devices_flag, str(max_devices)] if max_devices else []
@@ -197,8 +198,7 @@ class Xcodebuild(RunningCliAppMixin):
         return [
             *self._construct_base_command(custom_flags),
             *only_testing_args,
-            "-sdk",
-            sdk,
+            *sdk_args,
             *coverage_args,
             *reduce(add, destinations_args, []),
             *max_devices_args,
@@ -280,7 +280,7 @@ class Xcodebuild(RunningCliAppMixin):
 
     def test(
         self,
-        sdk: str,
+        sdk: Optional[str],
         simulators: List[Simulator],
         *,
         enable_code_coverage: bool = False,

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/tools/_app_store_connect/arguments.py

@@ -2,6 +2,7 @@ import argparse
 import json
 import pathlib
 import re
+import shlex
 from argparse import ArgumentTypeError
 from collections import Counter
 from dataclasses import dataclass
@@ -80,9 +81,8 @@ class Types:
         )
         environment_variable_key = "APP_STORE_CONNECT_PRIVATE_KEY"
 
-        @classmethod
-        def _apply_type(cls, non_typed_value: str) -> str:
-            pem_private_key = cls.argument_type(non_typed_value)
+        def _apply_type(self, non_typed_value: str) -> str:
+            pem_private_key = self.argument_type(non_typed_value)
             try:
                 _ = load_pem_private_key(pem_private_key.encode(), None)
             except ValueError as ve:
@@ -190,10 +190,9 @@ class Types:
                     ),
                 )
 
-        @classmethod
-        def _apply_type(cls, non_typed_value: str) -> datetime:
+        def _apply_type(self, non_typed_value: str) -> datetime:
             value = cli.CommonArgumentTypes.iso_8601_datetime(non_typed_value)
-            cls.validate(value)
+            self.validate(value)
             return value
 
     class AppStoreVersionInfoArgument(cli.EnvironmentArgumentValue[AppStoreVersionInfo]):
@@ -209,8 +208,7 @@ class Types:
             },
         )
 
-        @classmethod
-        def _apply_type(cls, non_typed_value: str) -> AppStoreVersionInfo:
+        def _apply_type(self, non_typed_value: str) -> AppStoreVersionInfo:
             try:
                 given_app_store_version_info = json.loads(non_typed_value)
                 assert isinstance(given_app_store_version_info, dict)
@@ -272,8 +270,7 @@ class Types:
             ],
         )
 
-        @classmethod
-        def _apply_type(cls, non_typed_value: str) -> List[AppStoreVersionLocalizationInfo]:
+        def _apply_type(self, non_typed_value: str) -> List[AppStoreVersionLocalizationInfo]:
             try:
                 given_localization_infos = json.loads(non_typed_value)
                 assert isinstance(given_localization_infos, list)
@@ -323,8 +320,7 @@ class Types:
         environment_variable_key = "APP_STORE_CONNECT_BETA_BUILD_LOCALIZATIONS"
         example_value = json.dumps([{"locale": "en-US", "whats_new": "What's new in English"}])
 
-        @classmethod
-        def _apply_type(cls, non_typed_value: str) -> List[BetaBuildInfo]:
+        def _apply_type(self, non_typed_value: str) -> List[BetaBuildInfo]:
             try:
                 given_beta_build_localizations = json.loads(non_typed_value)
                 assert isinstance(given_beta_build_localizations, list)
@@ -357,6 +353,21 @@ class Types:
 
             return beta_build_infos
 
+    class DeviceUdidsArgument(cli.EnvironmentArgumentValue[List[str]]):
+        argument_type = List[str]
+        environment_variable_key = "APP_STORE_CONNECT_DEVICE_UDIDS"
+        example_value = "00000000-000000000000001E"
+
+        def _apply_type(self, non_typed_value: str) -> List[str]:
+            is_from_cli = not (self._is_from_environment() or self._is_from_file() or self._from_environment)
+            if is_from_cli:
+                udids = [non_typed_value.strip()]
+            else:
+                udids = [udid.strip() for udid in shlex.split(non_typed_value) if udid.strip()]
+            if udids and all(udids):
+                return udids
+            raise argparse.ArgumentTypeError(f'Provided value "{non_typed_value}" is not valid')
+
 
 _API_DOCS_REFERENCE = f"Learn more at {AppStoreConnectApiClient.API_KEYS_DOCS_URL}."
 _LOCALE_CODES_URL = (
@@ -1212,19 +1223,24 @@ class DeviceArgument(cli.Argument):
     )
     DEVICE_NAME = cli.ArgumentProperties(
         key="device_name",
-        flags=("--name",),
-        description="Name of the Device",
+        flags=("--name", "-n"),
+        description="Common name of Devices",
         argparse_kwargs={"required": True},
     )
     DEVICE_NAME_OPTIONAL = cli.ArgumentProperties.duplicate(
         DEVICE_NAME,
         argparse_kwargs={"required": False},
     )
-    DEVICE_UDID = cli.ArgumentProperties(
-        key="device_udid",
-        flags=("--udid",),
-        description="Device ID (UDID)",
-        argparse_kwargs={"required": True},
+    DEVICE_UDIDS = cli.ArgumentProperties(
+        key="device_udids",
+        flags=("--udid", "-u"),
+        type=Types.DeviceUdidsArgument,
+        description=f"Device ID (UDID), for example: {Types.DeviceUdidsArgument.example_value}",
+        argparse_kwargs={
+            "required": False,
+            "nargs": "+",
+            "metavar": "UDID",
+        },
     )
     DEVICE_STATUS = cli.ArgumentProperties(
         key="device_status",
@@ -1236,6 +1252,20 @@ class DeviceArgument(cli.Argument):
             "choices": list(DeviceStatus),
         },
     )
+    IGNORE_REGISTRATION_ERRORS = cli.ArgumentProperties(
+        key="ignore_registration_errors",
+        flags=("--ignore-registration-errors",),
+        type=bool,
+        description=(
+            "Ignore device registration failures, e.g. invalid UDID or duplicate UDID submission. "
+            "Proceed registering remaining UDIDs when the flag is set."
+        ),
+        argparse_kwargs={
+            "required": False,
+            "action": "store_true",
+            "default": False,
+        },
+    )
 
 
 class CertificateArgument(cli.Argument):

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/tools/_xcode_project/arguments.py

@@ -33,8 +33,7 @@ class CustomExportOptions(cli.EnvironmentArgumentValue[dict]):
         },
     )
 
-    @classmethod
-    def _apply_type(cls, non_typed_value: str) -> Dict:
+    def _apply_type(self, non_typed_value: str) -> Dict:
         try:
             given_custom_export_options = json.loads(non_typed_value)
             if not isinstance(given_custom_export_options, dict):
@@ -320,6 +319,13 @@ class TestArgument(cli.Argument):
         description="Name of the SDK that should be used for building the application for testing.",
         argparse_kwargs={"required": False, "default": "iphonesimulator"},
     )
+    OMIT_TEST_SDK = cli.ArgumentProperties(
+        key="omit_test_sdk",
+        flags=("--omit-sdk",),
+        type=bool,
+        description="Do not pass -sdk argument to `xcodebuild test` command",
+        argparse_kwargs={"required": False, "action": "store_true"},
+    )
 
 
 class TestResultArgument(cli.Argument):

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/tools/android_keystore/argument_types.py

@@ -4,8 +4,7 @@ from codemagic import cli
 
 
 class Password(cli.EnvironmentArgumentValue[str]):
-    @classmethod
-    def _apply_type(cls, non_typed_value: str) -> str:
+    def _apply_type(self, non_typed_value: str) -> str:
         value = super()._apply_type(non_typed_value)
         if len(value) < 6:
             raise argparse.ArgumentTypeError("Minimum required password length is 6 characters")

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/tools/app_store_connect.py

@@ -492,25 +492,65 @@ class AppStoreConnect(
         "register-device",
         BundleIdArgument.PLATFORM,
         DeviceArgument.DEVICE_NAME,
-        DeviceArgument.DEVICE_UDID,
+        DeviceArgument.DEVICE_UDIDS,
+        DeviceArgument.IGNORE_REGISTRATION_ERRORS,
     )
     def register_device(
         self,
         platform: BundleIdPlatform,
         device_name: str,
-        device_udid: str,
+        device_udid: Optional[str] = None,  # Deprecated in https://github.com/codemagic-ci-cd/cli-tools/pull/331
+        device_udids: Optional[
+            Union[
+                str,
+                Types.DeviceUdidsArgument,
+                Sequence[Union[str, Types.DeviceUdidsArgument]],
+            ]
+        ] = None,
+        ignore_registration_errors: bool = DeviceArgument.IGNORE_REGISTRATION_ERRORS.get_default(),
         should_print: bool = True,
-    ) -> Device:
+    ) -> List[Device]:
         """
-        Register a new device for app development
+        Register new Devices for app development
         """
-        return self._create_resource(
-            self.api_client.devices,
-            should_print,
-            udid=device_udid,
-            name=device_name,
-            platform=platform,
-        )
+        if not device_udids and not device_udid:
+            DeviceArgument.DEVICE_UDIDS.raise_argument_error("At least one device UDID is required")
+
+        if device_udids is None:
+            device_udids = []
+        if isinstance(device_udids, str) or isinstance(device_udids, Types.DeviceUdidsArgument):
+            device_udids = [device_udids]
+
+        if device_udid:
+            device_udids = [device_udid, *device_udids]
+
+        device_udids_values: List[str] = []
+        for device_udids in device_udids:
+            if isinstance(device_udids, Types.DeviceUdidsArgument):
+                device_udids_values.extend(device_udids.value)
+            else:
+                device_udids_values.append(device_udids)
+
+        registered_devices = []
+        for device_udid in device_udids_values:
+            try:
+                device = self._create_resource(
+                    self.api_client.devices,
+                    should_print,
+                    udid=device_udid,
+                    name=device_name,
+                    platform=platform,
+                )
+            except AppStoreConnectError as error:
+                if not ignore_registration_errors:
+                    raise error
+                self.logger.error(Colors.YELLOW(f"Failed to register a device: {error.args[0]}"))
+            else:
+                registered_devices.append(device)
+
+            self.echo("") if should_print else None
+
+        return registered_devices
 
     @cli.action(
         "create-bundle-id",

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/tools/firebase_app_distribution/argument_types.py

@@ -9,8 +9,7 @@ class CredentialsArgument(cli.EnvironmentArgumentValue[dict]):
     argument_type = dict
     environment_variable_key = "FIREBASE_SERVICE_ACCOUNT_CREDENTIALS"
 
-    @classmethod
-    def _apply_type(cls, non_typed_value: str) -> Dict[str, str]:
+    def _apply_type(self, non_typed_value: str) -> Dict[str, str]:
         try:
             value = json.loads(non_typed_value)
         except json.decoder.JSONDecodeError as e:

{codemagic_cli_tools-0.40.5 → codemagic_cli_tools-0.42.0}/src/codemagic/tools/xcode_project.py

@@ -431,6 +431,7 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
         TestArgument.TEST_DEVICES,
         TestArgument.TEST_ONLY,
         TestArgument.TEST_SDK,
+        TestArgument.OMIT_TEST_SDK,
         TestResultArgument.OUTPUT_DIRECTORY,
         TestResultArgument.OUTPUT_EXTENSION,
         XcodeArgument.TEST_FLAGS,
@@ -459,6 +460,7 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
         output_dir: pathlib.Path = TestResultArgument.OUTPUT_DIRECTORY.get_default(),
         output_extension: str = TestResultArgument.OUTPUT_EXTENSION.get_default(),
         graceful_exit: bool = False,
+        omit_test_sdk: bool = False,
     ):
         """
         Run unit or UI tests for given Xcode project or workspace
@@ -473,7 +475,7 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
         xcresult_collector.ignore_results(Xcode.DERIVED_DATA_PATH)
         try:
             xcodebuild.test(
-                test_sdk,
+                None if omit_test_sdk else test_sdk,
                 simulators,
                 enable_code_coverage=not disable_code_coverage,
                 only_testing=test_only,
@@ -669,14 +671,18 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
                 f'File "{export_options_plist}" is not a valid property list',
             )
 
-    def _get_test_destinations(self, test_sdk: str, requested_devices: Optional[List[str]]) -> List[Simulator]:
+    def _get_test_destinations(
+        self,
+        test_sdk: str | None,
+        requested_devices: Optional[List[str]],
+    ) -> List[Simulator]:
         if requested_devices:
             try:
                 simulators = Simulator.find_simulators(requested_devices)
             except ValueError as ve:
                 raise TestArgument.TEST_DEVICES.raise_argument_error(str(ve)) from ve
-        elif "macos" in test_sdk.lower():
-            # macOS tests are run on the host machine and no test destinations are required
+        elif test_sdk and "macos" in test_sdk.lower():
+            # macOS tests run on the host machine and no test destinations are required
             simulators = []
         else:
             simulators = [self.get_default_test_destination(should_print=False)]