osc-lib 3.2.0__py3-none-any.whl → 4.0.1__py3-none-any.whl

osc_lib/shell.py

@@ -20,12 +20,15 @@ import getpass
 import logging
 import sys
 import traceback
+import typing as ty
 
+from cliff import _argparse
 from cliff import app
 from cliff import command
 from cliff import commandmanager
 from cliff import complete
 from cliff import help
+from cliff import interactive
 from oslo_utils import importutils
 from oslo_utils import strutils
 
@@ -45,7 +48,7 @@ DEFAULT_DOMAIN = 'default'
 DEFAULT_INTERFACE = 'public'
 
 
-def prompt_for_password(prompt=None):
+def prompt_for_password(prompt: ty.Optional[str] = None) -> str:
     """Prompt user for a password
 
     Prompt for a password if stdin is a tty.
@@ -76,26 +79,30 @@ def prompt_for_password(prompt=None):
 class OpenStackShell(app.App):
     CONSOLE_MESSAGE_FORMAT = '%(levelname)s: %(name)s %(message)s'
 
+    client_manager: clientmanager.ClientManager
+
     log = logging.getLogger(__name__)
-    timing_data = []
+    timing_data: ty.List[ty.Any] = []
 
     def __init__(
         self,
-        description=None,
-        version=None,
-        command_manager=None,
-        stdin=None,
-        stdout=None,
-        stderr=None,
-        interactive_app_factory=None,
-        deferred_help=False,
-    ):
+        description: ty.Optional[str] = None,
+        version: ty.Optional[str] = None,
+        command_manager: ty.Optional[commandmanager.CommandManager] = None,
+        stdin: ty.Optional[ty.TextIO] = None,
+        stdout: ty.Optional[ty.TextIO] = None,
+        stderr: ty.Optional[ty.TextIO] = None,
+        interactive_app_factory: ty.Optional[
+            ty.Type['interactive.InteractiveApp']
+        ] = None,
+        deferred_help: bool = False,
+    ) -> None:
         # Patch command.Command to add a default auth_required = True
-        command.Command.auth_required = True
+        setattr(command.Command, 'auth_required', True)
 
         # Some commands do not need authentication
-        help.HelpCommand.auth_required = False
-        complete.CompleteCommand.auth_required = False
+        setattr(help.HelpCommand, 'auth_required', False)
+        setattr(complete.CompleteCommand, 'auth_required', False)
 
         # Slight change to the meaning of --debug
         self.DEFAULT_DEBUG_VALUE = None
@@ -120,17 +127,16 @@ class OpenStackShell(app.App):
         # Set in subclasses
         self.api_version = None
 
-        self.client_manager = None
-        self.command_options = None
+        self.command_options: ty.List[str] = []
 
         self.do_profile = False
 
-    def configure_logging(self):
+    def configure_logging(self) -> None:
         """Configure logging for the app."""
         self.log_configurator = logs.LogConfigurator(self.options)
         self.dump_stack_trace = self.log_configurator.dump_trace
 
-    def run(self, argv):
+    def run(self, argv: ty.List[str]) -> int:
         ret_val = 1
         self.command_options = argv
         try:
@@ -149,12 +155,12 @@ class OpenStackShell(app.App):
         finally:
             self.log.debug("END return value: %s", ret_val)
 
-    def init_profile(self):
+    def init_profile(self) -> None:
         self.do_profile = osprofiler_profiler and self.options.profile
         if self.do_profile:
             osprofiler_profiler.init(self.options.profile)
 
-    def close_profile(self):
+    def close_profile(self) -> None:
         if self.do_profile:
             profiler = osprofiler_profiler.get()
             trace_id = profiler.get_base_id()
@@ -167,14 +173,14 @@ class OpenStackShell(app.App):
             # that (PROFILE = 60 for instance), but not sure we need it here.
             self.log.warning(f"Trace ID: {trace_id}")
             self.log.warning(
-                "Short trace ID " f"for OpenTracing-based drivers: {short_id}"
+                f"Short trace ID for OpenTracing-based drivers: {short_id}"
             )
             self.log.warning(
                 "Display trace data with command:\n"
                 f"osprofiler trace show --html {trace_id} "
             )
 
-    def run_subcommand(self, argv):
+    def run_subcommand(self, argv: ty.List[str]) -> int:
         self.init_profile()
         try:
             ret_value = super().run_subcommand(argv)
@@ -182,7 +188,7 @@ class OpenStackShell(app.App):
             self.close_profile()
         return ret_value
 
-    def interact(self):
+    def interact(self) -> None:
         self.init_profile()
         try:
             ret_value = super().interact()
@@ -190,8 +196,17 @@ class OpenStackShell(app.App):
             self.close_profile()
         return ret_value
 
-    def build_option_parser(self, description, version):
-        parser = super().build_option_parser(description, version)
+    def build_option_parser(
+        self,
+        description: ty.Optional[str],
+        version: ty.Optional[str],
+        argparse_kwargs: ty.Optional[ty.Dict[str, ty.Any]] = None,
+    ) -> _argparse.ArgumentParser:
+        parser = super().build_option_parser(
+            description,
+            version,
+            argparse_kwargs,
+        )
 
         # service token auth argument
         parser.add_argument(
@@ -248,9 +263,7 @@ class OpenStackShell(app.App):
             metavar='<auth-domain>',
             dest='default_domain',
             default=utils.env('OS_DEFAULT_DOMAIN', default=DEFAULT_DOMAIN),
-            help=_(
-                'Default domain ID, default=%s. ' '(Env: OS_DEFAULT_DOMAIN)'
-            )
+            help=_('Default domain ID, default=%s. (Env: OS_DEFAULT_DOMAIN)')
             % DEFAULT_DOMAIN,
         )
         parser.add_argument(
@@ -347,7 +360,6 @@ class OpenStackShell(app.App):
             )
 
         return parser
-        # return clientmanager.build_plugin_option_parser(parser)
 
     """
     Break up initialize_app() so that overriding it in a subclass does not
@@ -363,7 +375,7 @@ class OpenStackShell(app.App):
 
     """
 
-    def _final_defaults(self):
+    def _final_defaults(self) -> None:
         # Set the default plugin to None
         # NOTE(dtroyer): This is here to set up for setting it to a default
         #                in the calling CLI
@@ -390,21 +402,21 @@ class OpenStackShell(app.App):
         # Save default domain
         self.default_domain = self.options.default_domain
 
-    def _load_plugins(self):
+    def _load_plugins(self) -> None:
         """Load plugins via stevedore
 
         osc-lib has no opinion on what plugins should be loaded
         """
         pass
 
-    def _load_commands(self):
+    def _load_commands(self) -> None:
         """Load commands via cliff/stevedore
 
         osc-lib has no opinion on what commands should be loaded
         """
         pass
 
-    def initialize_app(self, argv):
+    def initialize_app(self, argv: ty.List[str]) -> None:
         """Global app init bits:
 
         * set up API versions
@@ -416,7 +428,9 @@ class OpenStackShell(app.App):
         super().initialize_app(argv)
         self.log.info(
             "START with options: %s",
-            strutils.mask_password(" ".join(self.command_options)),
+            strutils.mask_password(" ".join(self.command_options))
+            if self.command_options
+            else "",
         )
         self.log.debug("options: %s", strutils.mask_password(self.options))
 
@@ -473,23 +487,23 @@ class OpenStackShell(app.App):
             pw_func=prompt_for_password,
         )
 
-    def prepare_to_run_command(self, cmd):
+    def prepare_to_run_command(self, cmd: 'command.Command') -> None:
         """Set up auth and API versions"""
         self.log.debug(
             'command: %s -> %s.%s (auth=%s)',
             getattr(cmd, 'cmd_name', '<none>'),
             cmd.__class__.__module__,
             cmd.__class__.__name__,
-            cmd.auth_required,
+            getattr(cmd, 'auth_required', None),
         )
 
         # NOTE(dtroyer): If auth is not required for a command, skip
         #                get_one()'s validation to avoid loading plugins
-        validate = cmd.auth_required
+        validate = getattr(cmd, 'auth_required', False)
 
         # NOTE(dtroyer): Save the auth required state of the _current_ command
         #                in the ClientManager
-        self.client_manager._auth_required = cmd.auth_required
+        self.client_manager._auth_required = validate
 
         # Validate auth options
         self.cloud = self.cloud_config.get_one(
@@ -503,26 +517,31 @@ class OpenStackShell(app.App):
         # Push the updated args into ClientManager
         self.client_manager._cli_options = self.cloud
 
-        if cmd.auth_required:
+        if validate:
             self.client_manager.setup_auth()
             if hasattr(cmd, 'required_scope') and cmd.required_scope:
                 # let the command decide whether we need a scoped token
                 self.client_manager.validate_scope()
             # Trigger the Identity client to initialize
-            self.client_manager.session.auth.auth_ref = (
+            self.client_manager.session.auth.auth_ref = (  # type: ignore
                 self.client_manager.auth_ref
             )
         return
 
-    def clean_up(self, cmd, result, err):
+    def clean_up(
+        self,
+        cmd: 'command.Command',
+        result: int,
+        err: ty.Optional[BaseException],
+    ) -> None:
         self.log.debug('clean_up %s: %s', cmd.__class__.__name__, err or '')
 
         # Close SDK connection if available to have proper cleanup there
-        if hasattr(self.client_manager, "sdk_connection"):
+        if getattr(self.client_manager, "sdk_connection", None) is not None:
             self.client_manager.sdk_connection.close()
 
         # Close session if available
-        if hasattr(self.client_manager.session, "session"):
+        if getattr(self.client_manager.session, "session", None) is not None:
             self.client_manager.session.session.close()
 
         # Process collected timing data
@@ -541,6 +560,7 @@ class OpenStackShell(app.App):
             # Check the formatter used in the actual command
             if (
                 hasattr(cmd, 'formatter')
+                and hasattr(cmd, '_formatter_plugins')
                 and cmd.formatter != cmd._formatter_plugins['table'].obj
             ):
                 format = 'csv'
@@ -550,7 +570,7 @@ class OpenStackShell(app.App):
             tcmd.run(targs)
 
 
-def main(argv=None):
+def main(argv: ty.Optional[ty.List[str]] = None) -> int:
     if argv is None:
         argv = sys.argv[1:]
     return OpenStackShell().run(argv)

osc_lib/tests/test_shell.py

@@ -288,19 +288,19 @@ class TestShellCli(utils.TestShell):
 
         # Default
         utils.fake_execute(_shell, "module list")
-        self.assertEqual('', _shell.options.cert)
-        self.assertEqual('', _shell.options.key)
+        self.assertIsNone(_shell.options.cert)
+        self.assertIsNone(_shell.options.key)
         self.assertIsNone(_shell.client_manager.cert)
 
         # --os-cert
         utils.fake_execute(_shell, "--os-cert mycert module list")
         self.assertEqual('mycert', _shell.options.cert)
-        self.assertEqual('', _shell.options.key)
+        self.assertIsNone(_shell.options.key)
         self.assertEqual('mycert', _shell.client_manager.cert)
 
         # --os-key
         utils.fake_execute(_shell, "--os-key mickey module list")
-        self.assertEqual('', _shell.options.cert)
+        self.assertIsNone(_shell.options.cert)
         self.assertEqual('mickey', _shell.options.key)
         self.assertIsNone(_shell.client_manager.cert)
 

osc_lib/tests/utils/__init__.py

@@ -14,7 +14,6 @@
 #   under the License.
 #
 
-import contextlib
 import copy
 import json as jsonutils
 import os
@@ -111,24 +110,6 @@ class TestCase(testtools.TestCase):
                 msg = f'method {m} should not have been called'
             self.fail(msg)
 
-    @contextlib.contextmanager
-    def subTest(self, *args, **kwargs):
-        """This is a wrapper to unittest's subTest method.
-
-        This wrapper suppresses 2 issues:
-         * lack of support in older Python versions
-         * bug in testtools that breaks support for all versions
-        """
-        try:
-            with super().subTest(*args, **kwargs):
-                yield
-        except TypeError:
-            raise
-        except AttributeError:
-            # TODO(elhararb): remove this except clause when subTest is
-            #                 enabled in testtools
-            yield
-
 
 class TestCommand(TestCase):
     """Test cliff command classes"""

osc_lib/tests/utils/test_tags.py

@@ -13,6 +13,7 @@
 #   under the License.
 
 import argparse
+import functools
 import sys
 from unittest import mock
 
@@ -27,7 +28,9 @@ def help_enhancer(_h):
 
 class TestTags(test_utils.TestCase):
     def test_add_tag_filtering_option_to_parser(self):
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         tags.add_tag_filtering_option_to_parser(parser, 'test')
 
         parsed_args = parser.parse_args(
@@ -60,7 +63,9 @@ class TestTags(test_utils.TestCase):
         self.assertCountEqual(expected, actual)
 
     def test_get_tag_filtering_args(self):
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         tags.add_tag_filtering_option_to_parser(parser, 'test')
 
         parsed_args = parser.parse_args(
@@ -86,7 +91,9 @@ class TestTags(test_utils.TestCase):
         self.assertEqual(expected, args)
 
     def test_add_tag_option_to_parser_for_create(self):
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         tags.add_tag_option_to_parser_for_create(parser, 'test')
 
         # Test that --tag and --no-tag are mutually exclusive
@@ -105,7 +112,9 @@ class TestTags(test_utils.TestCase):
         self.assertCountEqual(expected, actual)
 
     def test_add_tag_option_to_parser_for_set(self):
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         tags.add_tag_option_to_parser_for_set(parser, 'test')
 
         parsed_args = parser.parse_args(['--tag', 'tag1'])
@@ -119,7 +128,9 @@ class TestTags(test_utils.TestCase):
         self.assertCountEqual(expected, actual)
 
     def test_add_tag_option_to_parser_for_unset(self):
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         tags.add_tag_option_to_parser_for_unset(parser, 'test')
 
         # Test that --tag and --all-tag are mutually exclusive
@@ -209,11 +220,15 @@ class TestTagHelps(test_utils.TestCase):
             options_name = 'options'
         else:
             options_name = 'optional arguments'
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         meth(parser, 'test')
         self.assertEqual(exp_normal % options_name, parser.format_help())
 
-        parser = argparse.ArgumentParser()
+        parser = argparse.ArgumentParser(
+            formatter_class=functools.partial(argparse.HelpFormatter, width=78)
+        )
         meth(parser, 'test', enhance_help=help_enhancer)
         self.assertEqual(exp_enhanced % options_name, parser.format_help())
 

osc_lib/tests/utils/test_utils.py

@@ -460,11 +460,6 @@ class TestUtils(test_utils.TestCase):
         self.assertEqual('fake-id', res_id)
         return res_attr
 
-    def test_get_item_properties_with_format_func(self):
-        formatters = {'attr': utils.format_list}
-        res_attr = self._test_get_item_properties_with_formatter(formatters)
-        self.assertEqual(utils.format_list(['a', 'b']), res_attr)
-
     def test_get_item_properties_with_formattable_column(self):
         formatters = {'attr': format_columns.ListColumn}
         res_attr = self._test_get_item_properties_with_formatter(formatters)
@@ -479,11 +474,6 @@ class TestUtils(test_utils.TestCase):
         self.assertEqual('fake-id', res_id)
         return res_attr
 
-    def test_get_dict_properties_with_format_func(self):
-        formatters = {'attr': utils.format_list}
-        res_attr = self._test_get_dict_properties_with_formatter(formatters)
-        self.assertEqual(utils.format_list(['a', 'b']), res_attr)
-
     def test_get_dict_properties_with_formattable_column(self):
         formatters = {'attr': format_columns.ListColumn}
         res_attr = self._test_get_dict_properties_with_formatter(formatters)
@@ -711,7 +701,7 @@ class TestFindResource(test_utils.TestCase):
             self.name,
         )
         self.assertEqual(
-            "More than one resource exists " "with the name or ID 'legos'.",
+            "More than one resource exists with the name or ID 'legos'.",
             str(result),
         )
         self.manager.get.assert_called_with(self.name)