osc-lib 3.1.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

osc_lib/logs.py

@@ -13,19 +13,24 @@
 
 """Application logging"""
 
+import argparse
+import collections.abc
 import logging
 import sys
+import typing as ty
 import warnings
 
+from openstack.config import cloud_config
 
-def get_loggers():
+
+def get_loggers() -> dict[str, str]:
     loggers = {}
     for logkey in logging.Logger.manager.loggerDict.keys():
         loggers[logkey] = logging.getLevelName(logging.getLogger(logkey).level)
     return loggers
 
 
-def log_level_from_options(options):
+def log_level_from_options(options: argparse.Namespace) -> int:
     # if --debug, --quiet or --verbose is not specified,
     # the default logging level is warning
     log_level = logging.WARNING
@@ -41,7 +46,7 @@ def log_level_from_options(options):
     return log_level
 
 
-def log_level_from_string(level_string):
+def log_level_from_string(level_string: str) -> int:
     log_level = {
         'critical': logging.CRITICAL,
         'error': logging.ERROR,
@@ -52,7 +57,7 @@ def log_level_from_string(level_string):
     return log_level
 
 
-def log_level_from_config(config):
+def log_level_from_config(config: collections.abc.Mapping[str, ty.Any]) -> int:
     # Check the command line option
     verbose_level = config.get('verbose_level')
     if config.get('debug', False):
@@ -70,7 +75,7 @@ def log_level_from_config(config):
     return log_level_from_string(verbose_level)
 
 
-def set_warning_filter(log_level):
+def set_warning_filter(log_level: int) -> None:
     if log_level == logging.ERROR:
         warnings.simplefilter("ignore")
     elif log_level == logging.WARNING:
@@ -89,7 +94,12 @@ class _FileFormatter(logging.Formatter):
     _LOG_MESSAGE_END = '%(message)s'
     _LOG_DATE_FORMAT = '%Y-%m-%d %H:%M:%S'
 
-    def __init__(self, options=None, config=None, **kwargs):
+    def __init__(
+        self,
+        options: ty.Optional[argparse.Namespace] = None,
+        config: ty.Optional[cloud_config.CloudConfig] = None,
+        **kwargs: ty.Any,
+    ) -> None:
         context = {}
         if options:
             context = {
@@ -114,10 +124,10 @@ class _FileFormatter(logging.Formatter):
         logging.Formatter.__init__(self, self.fmt, self._LOG_DATE_FORMAT)
 
 
-class LogConfigurator(object):
+class LogConfigurator:
     _CONSOLE_MESSAGE_FORMAT = '%(message)s'
 
-    def __init__(self, options):
+    def __init__(self, options: argparse.Namespace) -> None:
         self.root_logger = logging.getLogger('')
         self.root_logger.setLevel(logging.DEBUG)
 
@@ -166,7 +176,7 @@ class LogConfigurator(object):
         stevedore_log.setLevel(logging.ERROR)
         iso8601_log.setLevel(logging.ERROR)
 
-    def configure(self, cloud_config):
+    def configure(self, cloud_config: cloud_config.CloudConfig) -> None:
         log_level = log_level_from_config(cloud_config.config)
         set_warning_filter(log_level)
         self.dump_trace = cloud_config.config.get('debug', self.dump_trace)

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: 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[
+            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
@@ -107,7 +114,7 @@ class OpenStackShell(app.App):
         else:
             cm = command_manager
 
-        super(OpenStackShell, self).__init__(
+        super().__init__(
             description=__doc__.strip(),
             version=version,
             command_manager=cm,
@@ -120,21 +127,20 @@ class OpenStackShell(app.App):
         # Set in subclasses
         self.api_version = None
 
-        self.client_manager = None
-        self.command_options = None
+        self.command_options: 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: list[str]) -> int:
         ret_val = 1
         self.command_options = argv
         try:
-            ret_val = super(OpenStackShell, self).run(argv)
+            ret_val = super().run(argv)
             return ret_val
         except Exception as e:
             if not logging.getLogger('').handlers:
@@ -147,14 +153,14 @@ class OpenStackShell(app.App):
             return ret_val
 
         finally:
-            self.log.info("END return value: %s", ret_val)
+            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()
@@ -165,35 +171,41 @@ class OpenStackShell(app.App):
             # printed. In fact we can define custom log level here with value
             # bigger than most big default one (CRITICAL) or something like
             # that (PROFILE = 60 for instance), but not sure we need it here.
-            self.log.warning("Trace ID: %s" % trace_id)
+            self.log.warning(f"Trace ID: {trace_id}")
             self.log.warning(
-                "Short trace ID "
-                "for OpenTracing-based drivers: %s" % short_id
+                f"Short trace ID for OpenTracing-based drivers: {short_id}"
             )
             self.log.warning(
                 "Display trace data with command:\n"
-                "osprofiler trace show --html %s " % trace_id
+                f"osprofiler trace show --html {trace_id} "
             )
 
-    def run_subcommand(self, argv):
+    def run_subcommand(self, argv: list[str]) -> int:
         self.init_profile()
         try:
-            ret_value = super(OpenStackShell, self).run_subcommand(argv)
+            ret_value = super().run_subcommand(argv)
         finally:
             self.close_profile()
         return ret_value
 
-    def interact(self):
+    def interact(self) -> None:
         self.init_profile()
         try:
-            ret_value = super(OpenStackShell, self).interact()
+            ret_value = super().interact()
         finally:
             self.close_profile()
         return ret_value
 
-    def build_option_parser(self, description, version):
-        parser = super(OpenStackShell, self).build_option_parser(
-            description, version
+    def build_option_parser(
+        self,
+        description: ty.Optional[str],
+        version: ty.Optional[str],
+        argparse_kwargs: ty.Optional[dict[str, ty.Any]] = None,
+    ) -> _argparse.ArgumentParser:
+        parser = super().build_option_parser(
+            description,
+            version,
+            argparse_kwargs,
         )
 
         # service token auth argument
@@ -251,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(
@@ -350,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
@@ -366,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
@@ -393,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: list[str]) -> None:
         """Global app init bits:
 
         * set up API versions
@@ -416,10 +425,12 @@ class OpenStackShell(app.App):
         """
 
         # Parent __init__ parses argv into self.options
-        super(OpenStackShell, self).initialize_app(argv)
+        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))
 
@@ -435,7 +446,7 @@ class OpenStackShell(app.App):
                     'auth_type': self._auth_type,
                 },
             )
-        except (IOError, OSError) as e:
+        except OSError as e:
             self.log.critical("Could not read clouds.yaml configuration file")
             self.print_help_if_requested()
             raise e
@@ -476,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.info(
+        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(
@@ -506,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
@@ -544,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'
@@ -553,7 +570,7 @@ class OpenStackShell(app.App):
             tcmd.run(targs)
 
 
-def main(argv=None):
+def main(argv: ty.Optional[list[str]] = None) -> int:
     if argv is None:
         argv = sys.argv[1:]
     return OpenStackShell().run(argv)

osc_lib/tests/api/fakes.py

@@ -50,6 +50,6 @@ class TestSession(utils.TestCase):
     BASE_URL = 'https://api.example.com:1234/test'
 
     def setUp(self):
-        super(TestSession, self).setUp()
+        super().setUp()
         self.sess = session.Session()
         self.requests_mock = self.useFixture(fixture.Fixture())

osc_lib/tests/api/test_api.py

@@ -23,7 +23,7 @@ from osc_lib.tests.api import fakes as api_fakes
 
 class TestBaseAPIDefault(api_fakes.TestSession):
     def setUp(self):
-        super(TestBaseAPIDefault, self).setUp()
+        super().setUp()
         self.api = api.BaseAPI()
 
     def test_baseapi_request_no_url(self):
@@ -186,7 +186,7 @@ class TestBaseAPIEndpointArg(api_fakes.TestSession):
 
 class TestBaseAPIArgs(api_fakes.TestSession):
     def setUp(self):
-        super(TestBaseAPIArgs, self).setUp()
+        super().setUp()
         self.api = api.BaseAPI(
             session=self.sess,
             endpoint=self.BASE_URL,
@@ -220,7 +220,7 @@ class TestBaseAPIArgs(api_fakes.TestSession):
 
 class TestBaseAPICreate(api_fakes.TestSession):
     def setUp(self):
-        super(TestBaseAPICreate, self).setUp()
+        super().setUp()
         self.api = api.BaseAPI(
             session=self.sess,
             endpoint=self.BASE_URL,
@@ -258,7 +258,7 @@ class TestBaseAPICreate(api_fakes.TestSession):
 
 class TestBaseAPIFind(api_fakes.TestSession):
     def setUp(self):
-        super(TestBaseAPIFind, self).setUp()
+        super().setUp()
         self.api = api.BaseAPI(
             session=self.sess,
             endpoint=self.BASE_URL,
@@ -452,7 +452,7 @@ class TestBaseAPIFind(api_fakes.TestSession):
 
 class TestBaseAPIList(api_fakes.TestSession):
     def setUp(self):
-        super(TestBaseAPIList, self).setUp()
+        super().setUp()
         self.api = api.BaseAPI(
             session=self.sess,
             endpoint=self.BASE_URL,

osc_lib/tests/api/test_utils.py

@@ -24,7 +24,7 @@ class TestBaseAPIFilter(api_fakes.TestSession):
     """The filters can be tested independently"""
 
     def setUp(self):
-        super(TestBaseAPIFilter, self).setUp()
+        super().setUp()
         self.api = api.BaseAPI(
             session=self.sess,
             endpoint=self.BASE_URL,

osc_lib/tests/cli/test_client_config.py

@@ -17,7 +17,7 @@ from osc_lib.tests import utils
 
 class TestOSCConfig(utils.TestCase):
     def setUp(self):
-        super(TestOSCConfig, self).setUp()
+        super().setUp()
 
         self.cloud = client_config.OSC_Config()
 

osc_lib/tests/cli/test_format_columns.py

@@ -104,7 +104,7 @@ class TestListDictColumn(utils.TestCase):
         # OrderedDict is a subclass of dict and would inadvertently pass
         self.assertEqual(type(col.machine_readable()), list)  # noqa: H212
         for x in col.machine_readable():
-            self.assertEqual(type(x), dict)  # noqa: H212
+            self.assertEqual(type(x), dict)  # noqa: H211
 
 
 class TestSizeColumn(utils.TestCase):