codemagic-cli-tools 0.53.4__tar.gz → 0.53.5__tar.gz

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/PKG-INFO

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

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

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/__version__.py

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

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/__version__.py-e

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

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/cli/__init__.py

@@ -6,6 +6,7 @@ from .argument import Argument
 from .argument import ArgumentProperties
 from .argument import CommonArgumentTypes
 from .argument import EnvironmentArgumentValue
+from .argument import MutuallyExclusiveGroup
 from .argument import TypedCliArgument
 from .cli_app import CliApp
 from .cli_app import CliAppException

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/cli/argument/__init__.py

@@ -5,5 +5,6 @@ from .argument_formatter import ArgumentFormatter
 from .argument_parser_builder import ArgumentParserBuilder
 from .argument_properties import ArgumentProperties
 from .common_argument_types import CommonArgumentTypes
+from .mutually_exclusive_groups import MutuallyExclusiveGroup
 from .typed_cli_argument import EnvironmentArgumentValue
 from .typed_cli_argument import TypedCliArgument

codemagic_cli_tools-0.53.5/src/codemagic/cli/argument/argument_parser_builder.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import argparse
+import dataclasses
+from typing import TYPE_CHECKING
+from typing import Dict
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import Type
+
+from codemagic.cli.cli_help_formatter import CliHelpFormatter
+from codemagic.cli.colors import Colors
+
+from .argument_formatter import ArgumentFormatter
+from .mutually_exclusive_groups import MutuallyExclusiveGroup
+from .mutually_exclusive_groups import MutuallyExclusiveGroups
+
+if TYPE_CHECKING:
+    from argparse import _ArgumentGroup as ArgumentGroup
+    from argparse import _SubParsersAction as SubParsersAction
+
+    from codemagic.cli import Argument
+    from codemagic.cli.argument import ActionCallable
+    from codemagic.cli.cli_app import CliApp
+
+
+@dataclasses.dataclass
+class _ArgumentGroups:
+    required: Optional[ArgumentGroup] = None
+    optionals: Optional[ArgumentGroup] = None
+    mutually_exclusive: Dict[MutuallyExclusiveGroup, ArgumentGroup] = dataclasses.field(default_factory=dict)
+    custom: Dict[str, ArgumentGroup] = dataclasses.field(default_factory=dict)
+
+    def register_arguments(self, arguments: Sequence[Argument]):
+        argument_group: Optional[ArgumentGroup]
+        for argument in arguments:
+            if argument.argument_group_name:
+                argument_group = self.custom[argument.argument_group_name]
+            elif argument.mutually_exclusive_group:
+                argument_group = self.mutually_exclusive[argument.mutually_exclusive_group]
+            elif argument.is_required():
+                argument_group = self.required
+            else:
+                argument_group = self.optionals
+
+            if argument_group:
+                argument.register(argument_group)
+
+
+class ArgumentParserBuilder:
+    def __init__(
+        self,
+        cli_app: Type[CliApp],
+        cli_action: ActionCallable,
+        parent_parser: SubParsersAction,
+        for_deprecated_alias: bool = False,
+    ):
+        self._cli_app = cli_app
+        self._cli_action = cli_action
+        self._action_parser = self._create_action_parser(parent_parser, for_deprecated_alias)
+
+    def _create_action_parser(self, parent_parser: SubParsersAction, for_deprecated_alias: bool):
+        if for_deprecated_alias:
+            if self._cli_action.deprecation_info is None:
+                raise RuntimeError(f"Deprecated alias requested for {self._cli_action.action_name} without alias")
+
+            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.deprecation_info.alias,
+                formatter_class=CliHelpFormatter,
+                description=f"{deprecation_message} {Colors.BOLD(self._cli_action.__doc__)}",
+            )
+        else:
+            return parent_parser.add_parser(
+                self._cli_action.action_name,
+                formatter_class=CliHelpFormatter,
+                description=Colors.BOLD(self._cli_action.__doc__),
+                help=self._cli_action.__doc__,
+            )
+
+    @property
+    def _full_action_name(self) -> str:
+        executable = self._cli_app.get_executable_name()
+        if self._cli_action.action_group:
+            return f"{executable} {self._cli_action.action_group.name} {self._cli_action.action_name}"
+        else:
+            return f"{executable} {self._cli_action.action_name}"
+
+    @classmethod
+    def set_default_cli_options(cls, cli_options_parser):
+        options_group = cli_options_parser.add_argument_group(Colors.UNDERLINE("Options"))
+        options_group.add_argument(
+            "--log-stream",
+            type=str,
+            default="stderr",
+            choices=["stderr", "stdout"],
+            help=f'Log output stream. {ArgumentFormatter.format_default_value("stderr")}',
+        )
+        options_group.add_argument(
+            "--no-color",
+            dest="no_color",
+            action="store_true",
+            help="Do not use ANSI colors to format terminal output",
+        )
+        options_group.add_argument(
+            "--version",
+            dest="show_version",
+            action="store_true",
+            help="Show tool version and exit",
+        )
+        options_group.add_argument(
+            "-s",
+            "--silent",
+            dest="enable_logging",
+            action="store_false",
+            help="Disable log output for commands",
+        )
+        options_group.add_argument(
+            "-v",
+            "--verbose",
+            dest="verbose",
+            action="store_true",
+            help="Enable verbose logging for commands",
+        )
+
+        options_group.set_defaults(
+            enable_logging=True,
+            no_color=False,
+            show_version=False,
+            verbose=False,
+        )
+
+    @staticmethod
+    def _get_mutually_exclusive_group_texts(group: MutuallyExclusiveGroup, executable: str) -> Tuple[str, str]:
+        if group.required:
+            title_prefix, description_prefix, description_verb = "Required", "Exactly", "must"
+        else:
+            title_prefix, description_prefix, description_verb = "Optional", "Only", "can"
+
+        title = f"{title_prefix} mutually exclusive arguments for {executable} to {Colors.BOLD(group.name)}"
+        description = f"{description_prefix} one of those options {description_verb} be selected"
+        return title, description
+
+    def _setup_custom_argument_groups(self, group_names: Sequence[str], executable) -> Dict[str, ArgumentGroup]:
+        argument_groups = {}
+        for group_name in group_names:
+            description = f"Optional arguments for {executable} to {Colors.BOLD(group_name)}"
+            argument_group = self._action_parser.add_argument_group(Colors.UNDERLINE(description))
+            argument_groups[group_name] = argument_group
+        return argument_groups
+
+    def _setup_mutually_exclusive_groups(
+        self,
+        mutually_exclusive_groups: Sequence[MutuallyExclusiveGroup],
+        executable: str,
+    ) -> Dict[MutuallyExclusiveGroup, ArgumentGroup]:
+        argument_groups = {}
+        for mutually_exclusive_group in mutually_exclusive_groups:
+            title, description = self._get_mutually_exclusive_group_texts(mutually_exclusive_group, executable)
+            argument_group = self._action_parser.add_argument_group(Colors.UNDERLINE(title), description)
+            mutually_exclusive_argument_group = argument_group.add_mutually_exclusive_group(
+                required=mutually_exclusive_group.required,
+            )
+            argument_groups[mutually_exclusive_group] = mutually_exclusive_argument_group
+        return argument_groups
+
+    def _setup_cli_app_options(self):
+        executable = self._action_parser.prog.split()[0]
+
+        mutually_exclusive_groups = MutuallyExclusiveGroups.from_argument_list(self._cli_app.CLASS_ARGUMENTS)
+
+        argument_groups = _ArgumentGroups()
+
+        required_args_title = Colors.UNDERLINE(f"Required arguments for {Colors.BOLD(executable)}")
+        argument_groups.required = self._action_parser.add_argument_group(required_args_title)
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.required, executable),
+        )
+
+        optional_args_title = Colors.UNDERLINE(f"Optional arguments for {Colors.BOLD(executable)}")
+        argument_groups.optionals = self._action_parser.add_argument_group(optional_args_title)
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.optional, executable),
+        )
+
+        argument_groups.register_arguments(self._cli_app.CLASS_ARGUMENTS)
+
+    def _setup_cli_action_options(self):
+        executable = f"command {self._cli_action.action_name}"
+        mutually_exclusive_groups = MutuallyExclusiveGroups.from_argument_list(self._cli_action.arguments)
+
+        argument_groups = _ArgumentGroups()
+
+        required_args_title = f"Required arguments for command {Colors.BOLD(self._cli_action.action_name)}"
+        argument_groups.required = self._action_parser.add_argument_group(Colors.UNDERLINE(required_args_title))
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.required, executable),
+        )
+
+        optional_args_title = f"Optional arguments for command {Colors.BOLD(self._cli_action.action_name)}"
+        argument_groups.optionals = self._action_parser.add_argument_group(Colors.UNDERLINE(optional_args_title))
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.optional, executable),
+        )
+
+        custom_group_names = {a.argument_group_name for a in self._cli_action.arguments if a.argument_group_name}
+        argument_groups.custom = self._setup_custom_argument_groups(sorted(custom_group_names), executable)
+
+        argument_groups.register_arguments(self._cli_action.arguments)
+
+    def build(self) -> argparse.ArgumentParser:
+        self._setup_cli_app_options()
+        self._setup_cli_action_options()
+        self.set_default_cli_options(self._action_parser)
+        return self._action_parser

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/cli/argument/argument_properties.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import copy
+from typing import TYPE_CHECKING
 from typing import Any
 from typing import Callable
 from typing import Dict
@@ -11,6 +12,9 @@ from typing import Tuple
 from typing import Type
 from typing import Union
 
+if TYPE_CHECKING:
+    from codemagic.cli import MutuallyExclusiveGroup
+
 
 class ArgumentProperties(NamedTuple):
     key: str
@@ -19,6 +23,7 @@ class ArgumentProperties(NamedTuple):
     flags: Tuple[str, ...] = tuple()
     argparse_kwargs: Optional[Dict[str, Any]] = None
     argument_group_name: Optional[str] = None
+    mutually_exclusive_group: Optional[MutuallyExclusiveGroup] = None
 
     @classmethod
     def duplicate(cls, template: Union[Tuple, ArgumentProperties], **overwrites) -> ArgumentProperties:

codemagic_cli_tools-0.53.5/src/codemagic/cli/argument/mutually_exclusive_groups.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import dataclasses
+from typing import NamedTuple
+from typing import Sequence
+
+from .argument import Argument
+
+
+class MutuallyExclusiveGroup(NamedTuple):
+    name: str
+    required: bool
+
+
+@dataclasses.dataclass(frozen=True)
+class MutuallyExclusiveGroups:
+    required: Sequence[MutuallyExclusiveGroup]
+    optional: Sequence[MutuallyExclusiveGroup]
+
+    @classmethod
+    def from_argument_list(cls, arguments: Sequence[Argument]) -> MutuallyExclusiveGroups:
+        required_groups, optional_groups = set(), set()
+
+        for argument in arguments:
+            if not argument.mutually_exclusive_group:
+                continue
+            elif argument.mutually_exclusive_group.required:
+                required_groups.add(argument.mutually_exclusive_group)
+            else:
+                optional_groups.add(argument.mutually_exclusive_group)
+
+        return MutuallyExclusiveGroups(
+            required=tuple(required_groups),
+            optional=tuple(optional_groups),
+        )

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/tools/firebase_app_distribution/action_groups/releases_action_group.py

@@ -38,7 +38,7 @@ class ReleasesActionGroup(FirebaseAppDistributionAction, ABC):
         List releases for the Firebase application
         """
 
-        app_identifier = AppIdentifier(self.project_id, app_id)
+        app_identifier = AppIdentifier(self.project_number, app_id)
         try:
             releases = self.client.releases.list(app_identifier, order_by, limit)
         except GoogleError as e:

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/tools/firebase_app_distribution/actions/get_latest_build_version_action.py

@@ -18,7 +18,7 @@ class GetLatestBuildVersionAction(FirebaseAppDistributionAction, ABC):
         """
         Get latest build version from Firebase
         """
-        app_identifier = AppIdentifier(self.project_id, app_id)
+        app_identifier = AppIdentifier(self.project_number, app_id)
         try:
             releases = self.client.releases.list(app_identifier, limit=1)
         except GoogleError as e:

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/tools/firebase_app_distribution/arguments.py

@@ -4,13 +4,24 @@ from codemagic.google.resources import OrderBy
 
 from .argument_types import CredentialsArgument
 
+select_project_group = cli.MutuallyExclusiveGroup(
+    name="select project",
+    required=True,
+)
+
 
 class FirebaseArgument(cli.Argument):
     PROJECT_ID = cli.ArgumentProperties(
         key="project_id",
-        flags=("--project-id", "-p"),
-        description=f'Project ID in Firebase. For example `{Colors.WHITE("228333310124")}`',
-        argparse_kwargs={"required": True},
+        flags=("--project-id",),
+        description=f'Deprecated in version 0.53.5. Use `{Colors.BRIGHT_BLUE("--project-number")}` instead',
+        mutually_exclusive_group=select_project_group,
+    )
+    PROJECT_NUMBER = cli.ArgumentProperties(
+        key="project_number",
+        flags=("--project-number", "-p"),
+        description=f'Project number in Firebase. For example `{Colors.WHITE("228333310124")}`',
+        mutually_exclusive_group=select_project_group,
     )
     FIREBASE_SERVICE_ACCOUNT_CREDENTIALS = cli.ArgumentProperties(
         key="credentials",

codemagic_cli_tools-0.53.5/src/codemagic/tools/firebase_app_distribution/firebase_app_distribution.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+from typing import Dict
+from typing import Optional
+
+from codemagic import cli
+from codemagic.google.firebase_client import FirebaseClient
+from codemagic.utilities import log
+from codemagic.utilities.decorators import deprecated
+
+from .action_groups import ReleasesActionGroup
+from .actions import GetLatestBuildVersionAction
+from .arguments import FirebaseArgument
+
+
+@cli.common_arguments(
+    FirebaseArgument.PROJECT_ID,
+    FirebaseArgument.PROJECT_NUMBER,
+    FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS,
+)
+class FirebaseAppDistribution(
+    cli.CliApp,
+    GetLatestBuildVersionAction,
+    ReleasesActionGroup,
+):
+    """
+    Utility to list releases and retrieve the latest release build version number from Firebase
+    """
+
+    def __init__(
+        self,
+        credentials: Dict,
+        project_number: Optional[str] = None,
+        project_id: Optional[str] = None,
+        **kwargs,
+    ):
+        if not project_id and not project_number:
+            raise ValueError("Missing project_number")
+        super().__init__(**kwargs)
+        self.client = FirebaseClient(credentials)
+        self._project_id = project_id
+        self._project_number = project_number
+        if project_id:
+            _ = self.project_id  # Just to trigger deprecation warning
+
+    @property
+    @deprecated("0.53.5", 'Use "FirebaseAppDistribution.project_number" instead.')
+    def project_id(self):
+        return self.project_number
+
+    @property
+    def project_number(self):
+        if not self._project_number:
+            return self._project_id
+        return self._project_number
+
+    @classmethod
+    def from_cli_args(cls, cli_args: argparse.Namespace) -> FirebaseAppDistribution:
+        credentials_argument = FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS.from_args(cli_args)
+        if credentials_argument is None:
+            raise FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS.raise_argument_error()
+        project_id = FirebaseArgument.PROJECT_ID.from_args(cli_args)
+        if project_id:
+            message = (
+                "Deprecation warning! "
+                f'Flag "{FirebaseArgument.get_flag(FirebaseArgument.PROJECT_ID)}" was deprecated in version 0.53.5 '
+                "and is subject for removal in future releases. "
+                f'Use "{FirebaseArgument.get_flag(FirebaseArgument.PROJECT_NUMBER)}" instead.'
+            )
+            log.get_logger(cls).warning(cli.Colors.YELLOW(message))
+
+        project_number = FirebaseArgument.PROJECT_NUMBER.from_args(cli_args)
+
+        if not project_id and not project_number:
+            raise FirebaseArgument.PROJECT_NUMBER.raise_argument_error()
+
+        return FirebaseAppDistribution(
+            credentials_argument.value,
+            project_number=project_id or project_number,
+            **cls._parent_class_kwargs(cli_args),
+        )
+
+
+if __name__ == "__main__":
+    FirebaseAppDistribution.invoke_cli()

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/src/codemagic/tools/firebase_app_distribution/firebase_app_distribution_action.py

@@ -16,7 +16,7 @@ class FirebaseAppDistributionAction(ABC):
 
     @property
     @abstractmethod
-    def project_id(self):
+    def project_number(self):
         ...
 
     @classmethod

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.5}/tests/tools/test_firebase_app_distribution.py

@@ -21,6 +21,7 @@ from googleapiclient import discovery
 from oauth2client.service_account import ServiceAccountCredentials
 
 credentials_argument = FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS
+project_number_argument = FirebaseArgument.PROJECT_NUMBER
 project_id_argument = FirebaseArgument.PROJECT_ID
 
 
@@ -41,7 +42,8 @@ def register_args(cli_argument_group):
 def namespace_kwargs():
     ns_kwargs = {
         credentials_argument.key: CredentialsArgument('{"type":"service_account"}'),
-        project_id_argument.key: "228333310124",
+        project_number_argument.key: "228333310124",
+        project_id_argument.key: None,
     }
     for arg in FirebaseAppDistribution.CLASS_ARGUMENTS:
         if not hasattr(arg.type, "environment_variable_key"):
@@ -158,7 +160,7 @@ def app_identifier():
 
 @pytest.fixture
 def firebase_app_distribution(app_identifier):
-    return FirebaseAppDistribution({"type": "service_account"}, app_identifier.project_id)
+    return FirebaseAppDistribution({"type": "service_account"}, app_identifier.project_id, None)
 
 
 def test_list_releases(firebase_app_distribution, mock_releases_list, releases, app_identifier):

codemagic_cli_tools-0.53.4/src/codemagic/cli/argument/argument_parser_builder.py

@@ -1,154 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from typing import TYPE_CHECKING
-from typing import Dict
-from typing import Type
-
-from codemagic.cli.cli_help_formatter import CliHelpFormatter
-from codemagic.cli.colors import Colors
-
-from .argument_formatter import ArgumentFormatter
-
-if TYPE_CHECKING:
-    from argparse import _ArgumentGroup as ArgumentGroup
-    from argparse import _SubParsersAction as SubParsersAction
-
-    from codemagic.cli.argument import ActionCallable
-    from codemagic.cli.cli_app import CliApp
-
-
-class ArgumentParserBuilder:
-    def __init__(
-        self,
-        cli_app: Type[CliApp],
-        cli_action: ActionCallable,
-        parent_parser: SubParsersAction,
-        for_deprecated_alias: bool = False,
-    ):
-        self._cli_app = cli_app
-        self._cli_action = cli_action
-        self._action_parser = self._create_action_parser(parent_parser, for_deprecated_alias)
-        self._required_arguments = self._action_parser.add_argument_group(
-            Colors.UNDERLINE(f"Required arguments for command {Colors.BOLD(cli_action.action_name)}"),
-        )
-        self._optional_arguments = self._action_parser.add_argument_group(
-            Colors.UNDERLINE(f"Optional arguments for command {Colors.BOLD(cli_action.action_name)}"),
-        )
-        self._custom_arguments_groups: Dict[str, ArgumentGroup] = {}
-
-    def _create_action_parser(self, parent_parser: SubParsersAction, for_deprecated_alias: bool):
-        if for_deprecated_alias:
-            if self._cli_action.deprecation_info is None:
-                raise RuntimeError(f"Deprecated alias requested for {self._cli_action.action_name} without alias")
-
-            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.deprecation_info.alias,
-                formatter_class=CliHelpFormatter,
-                description=f"{deprecation_message} {Colors.BOLD(self._cli_action.__doc__)}",
-            )
-        else:
-            return parent_parser.add_parser(
-                self._cli_action.action_name,
-                formatter_class=CliHelpFormatter,
-                description=Colors.BOLD(self._cli_action.__doc__),
-                help=self._cli_action.__doc__,
-            )
-
-    @property
-    def _full_action_name(self) -> str:
-        executable = self._cli_app.get_executable_name()
-        if self._cli_action.action_group:
-            return f"{executable} {self._cli_action.action_group.name} {self._cli_action.action_name}"
-        else:
-            return f"{executable} {self._cli_action.action_name}"
-
-    @classmethod
-    def set_default_cli_options(cls, cli_options_parser):
-        options_group = cli_options_parser.add_argument_group(Colors.UNDERLINE("Options"))
-        options_group.add_argument(
-            "--log-stream",
-            type=str,
-            default="stderr",
-            choices=["stderr", "stdout"],
-            help=f'Log output stream. {ArgumentFormatter.format_default_value("stderr")}',
-        )
-        options_group.add_argument(
-            "--no-color",
-            dest="no_color",
-            action="store_true",
-            help="Do not use ANSI colors to format terminal output",
-        )
-        options_group.add_argument(
-            "--version",
-            dest="show_version",
-            action="store_true",
-            help="Show tool version and exit",
-        )
-        options_group.add_argument(
-            "-s",
-            "--silent",
-            dest="enable_logging",
-            action="store_false",
-            help="Disable log output for commands",
-        )
-        options_group.add_argument(
-            "-v",
-            "--verbose",
-            dest="verbose",
-            action="store_true",
-            help="Enable verbose logging for commands",
-        )
-
-        options_group.set_defaults(
-            enable_logging=True,
-            no_color=False,
-            show_version=False,
-            verbose=False,
-        )
-
-    def _get_custom_argument_group(self, group_name) -> ArgumentGroup:
-        try:
-            argument_group = self._custom_arguments_groups[group_name]
-        except KeyError:
-            group_description = Colors.UNDERLINE(
-                f"Optional arguments for command {self._cli_action.action_name} to {Colors.BOLD(group_name)}",
-            )
-            argument_group = self._action_parser.add_argument_group(group_description)
-            self._custom_arguments_groups[group_name] = argument_group
-        return argument_group
-
-    def _get_argument_group(self, argument) -> ArgumentGroup:
-        if argument.argument_group_name is None:
-            if argument.is_required():
-                argument_group = self._required_arguments
-            else:
-                argument_group = self._optional_arguments
-        else:
-            argument_group = self._get_custom_argument_group(argument.argument_group_name)
-        return argument_group
-
-    def _setup_cli_app_options(self):
-        executable = self._action_parser.prog.split()[0]
-        tool_required_arguments = self._action_parser.add_argument_group(
-            Colors.UNDERLINE(f"Required arguments for {Colors.BOLD(executable)}"),
-        )
-        tool_optional_arguments = self._action_parser.add_argument_group(
-            Colors.UNDERLINE(f"Optional arguments for {Colors.BOLD(executable)}"),
-        )
-        for argument in self._cli_app.CLASS_ARGUMENTS:
-            argument_group = tool_required_arguments if argument.is_required() else tool_optional_arguments
-            argument.register(argument_group)
-
-    def build(self) -> argparse.ArgumentParser:
-        self.set_default_cli_options(self._action_parser)
-        for argument in self._cli_action.arguments:
-            argument_group = self._get_argument_group(argument)
-            argument.register(argument_group)
-        self._setup_cli_app_options()
-        return self._action_parser