Bump pylint and flake8

knack/arguments.py

@@ -83,7 +83,7 @@ def __getattr__(self, name):
 
     def __setattr__(self, name, value):  # pylint: disable=inconsistent-return-statements
         if name == 'type':
-            return super(CLICommandArgument, self).__setattr__(name, value)
+            return super().__setattr__(name, value)
         self.type.settings[name] = value
 
 
@@ -186,7 +186,7 @@ def __call__(self, parser, namespace, values, option_string=None):
                     else:
                         namespace._argument_deprecations.append(deprecate_info)  # pylint: disable=protected-access
                     try:
-                        super(DeprecatedArgumentAction, self).__call__(parser, namespace, values, option_string)
+                        super().__call__(parser, namespace, values, option_string)
                     except NotImplementedError:
                         setattr(namespace, self.dest, values)
 
@@ -209,7 +209,7 @@ def __call__(self, parser, namespace, values, option_string=None):
                         else:
                             namespace._argument_deprecations.append(deprecated_opt)  # pylint: disable=protected-access
                     try:
-                        super(DeprecatedOptionAction, self).__call__(parser, namespace, values, option_string)
+                        super().__call__(parser, namespace, values, option_string)
                     except NotImplementedError:
                         setattr(namespace, self.dest, values)
 
@@ -243,7 +243,7 @@ def __call__(self, parser, namespace, values, option_string=None):
                     else:
                         namespace._argument_previews.append(preview_info)  # pylint: disable=protected-access
                     try:
-                        super(PreviewArgumentAction, self).__call__(parser, namespace, values, option_string)
+                        super().__call__(parser, namespace, values, option_string)
                     except NotImplementedError:
                         setattr(namespace, self.dest, values)
 
@@ -294,7 +294,7 @@ def __call__(self, parser, namespace, values, option_string=None):
                     else:
                         namespace._argument_experimentals.append(experimental_info)  # pylint: disable=protected-access
                     try:
-                        super(ExperimentalArgumentAction, self).__call__(parser, namespace, values, option_string)
+                        super().__call__(parser, namespace, values, option_string)
                     except NotImplementedError:
                         setattr(namespace, self.dest, values)
 

knack/commands.py

@@ -276,10 +276,10 @@ def _get_op_handler(operation):
                 op = getattr(op, part)
             if isinstance(op, types.FunctionType):
                 return op
-            # MethodType
+            # op as types.MethodType
             return op.__func__
-        except (ValueError, AttributeError):
-            raise ValueError("The operation '{}' is invalid.".format(operation))
+        except (ValueError, AttributeError) as ex:
+            raise ValueError("The operation '{}' is invalid.".format(operation)) from ex
 
     def deprecate(self, **kwargs):
         kwargs['object_type'] = 'command group'

knack/deprecation.py

@@ -84,7 +84,7 @@ def _default_get_message(self):
         self.expiration = expiration
         self._cli_version = cli_ctx.get_cli_version()
 
-        super(Deprecated, self).__init__(
+        super().__init__(
             cli_ctx=cli_ctx,
             object_type=object_type,
             target=target,
@@ -136,4 +136,4 @@ def get_implicit_deprecation_message(self):
             'tag_func': lambda _: '',
             'message_func': get_implicit_deprecation_message
         })
-        super(ImplicitDeprecated, self).__init__(**kwargs)
+        super().__init__(**kwargs)

knack/experimental.py

@@ -52,7 +52,7 @@ def __init__(self, cli_ctx, object_type='', target=None, tag_func=None, message_
         def _default_get_message(self):
             return status_tag_messages['experimental'].format("This " + self.object_type)
 
-        super(ExperimentalItem, self).__init__(
+        super().__init__(
             cli_ctx=cli_ctx,
             object_type=object_type,
             target=target,
@@ -73,4 +73,4 @@ def get_implicit_experimental_message(self):
             'tag_func': lambda _: '',
             'message_func': get_implicit_experimental_message
         })
-        super(ImplicitExperimentalItem, self).__init__(**kwargs)
+        super().__init__(**kwargs)

knack/help.py

@@ -91,7 +91,7 @@ def _normalize_text(s):
     def __init__(self, **kwargs):
         self._short_summary = ''
         self._long_summary = ''
-        super(HelpObject, self).__init__(**kwargs)
+        super().__init__(**kwargs)
 
     @property
     def short_summary(self):
@@ -122,7 +122,7 @@ def _load_help_file_from_string(text):
             return text
 
     def __init__(self, help_ctx, delimiters):  # pylint: disable=too-many-statements
-        super(HelpFile, self).__init__()
+        super().__init__()
         self.help_ctx = help_ctx
         self.delimiters = delimiters
         self.name = delimiters.split()[-1] if delimiters else delimiters
@@ -241,7 +241,7 @@ class GroupHelpFile(HelpFile):
 
     def __init__(self, help_ctx, delimiters, parser):
 
-        super(GroupHelpFile, self).__init__(help_ctx, delimiters)
+        super().__init__(help_ctx, delimiters)
         self.type = 'group'
 
         self.children = []
@@ -265,7 +265,7 @@ class CommandHelpFile(HelpFile):
 
     def __init__(self, help_ctx, delimiters, parser):
 
-        super(CommandHelpFile, self).__init__(help_ctx, delimiters)
+        super().__init__(help_ctx, delimiters)
         self.type = 'command'
 
         self.parameters = []
@@ -324,7 +324,7 @@ def _add_parameter_help(self, param):
         self.parameters.append(HelpParameter(**param_kwargs))
 
     def _load_from_data(self, data):
-        super(CommandHelpFile, self)._load_from_data(data)
+        super()._load_from_data(data)
 
         if isinstance(data, str) or not self.parameters or not data.get('parameters'):
             return
@@ -344,7 +344,7 @@ class HelpParameter(HelpObject):  # pylint: disable=too-many-instance-attributes
 
     def __init__(self, name_source, description, required, choices=None, default=None, group_name=None,
                  deprecate_info=None, preview_info=None, experimental_info=None, default_value_source=None):
-        super(HelpParameter, self).__init__()
+        super().__init__()
         self.name_source = name_source
         self.name = ' '.join(sorted(name_source))
         self.required = required

knack/output.py

@@ -74,11 +74,11 @@ def format_table(obj):
         should_sort_keys = not obj.is_query_active and not obj.table_transformer
         to = _TableOutput(should_sort_keys)
         return to.dump(result_list)
-    except:
+    except Exception as ex:
         logger.debug(traceback.format_exc())
         raise CLIError("Table output unavailable. "
                        "Use the --query option to specify an appropriate query. "
-                       "Use --debug for more info.")
+                       "Use --debug for more info.") from ex
 
 
 def format_tsv(obj):

knack/parser.py

@@ -107,7 +107,7 @@ def __init__(self, cli_ctx=None, cli_help=None, **kwargs):
         # or description for a command. We better stash it away before handing it off for
         # "normal" argparse handling...
         self._description = kwargs.pop('description', None)
-        super(CLICommandParser, self).__init__(**kwargs)
+        super().__init__(**kwargs)
 
     def load_command_table(self, command_loader):
         """ Process the command table and load it into the parser
@@ -221,7 +221,7 @@ def _get_subparser(self, path, group_table=None):
         return parent_subparser
 
     def validation_error(self, message):
-        return super(CLICommandParser, self).error(message)
+        return super().error(message)
 
     def is_group(self):
         """ Determine if this parser instance represents a group
@@ -257,7 +257,7 @@ def parse_args(self, args=None, namespace=None):
         by ArgumentParser.parse_args as usual
         """
         self._expand_prefixed_files(args)
-        return super(CLICommandParser, self).parse_args(args)
+        return super().parse_args(args)
 
     def _check_value(self, action, value):
         # Override to customize the error message when a argument is not among the available choices

knack/preview.py

@@ -52,7 +52,7 @@ def __init__(self, cli_ctx, object_type='', target=None, tag_func=None, message_
         def _default_get_message(self):
             return status_tag_messages['preview'].format("This " + self.object_type)
 
-        super(PreviewItem, self).__init__(
+        super().__init__(
             cli_ctx=cli_ctx,
             object_type=object_type,
             target=target,
@@ -73,4 +73,4 @@ def get_implicit_preview_message(self):
             'tag_func': lambda _: '',
             'message_func': get_implicit_preview_message
         })
-        super(ImplicitPreviewItem, self).__init__(**kwargs)
+        super().__init__(**kwargs)

knack/query.py

@@ -22,9 +22,9 @@ def jmespath_type(raw_query):
         from jmespath import compile as compile_jmespath
         try:
             return compile_jmespath(raw_query)
-        except KeyError:
+        except KeyError as ex:
             # Raise a ValueError which argparse can handle
-            raise ValueError
+            raise ValueError from ex
 
     @staticmethod
     def on_global_arguments(_, **kwargs):

knack/testsdk/base.py

@@ -26,7 +26,7 @@
 
 class IntegrationTestBase(unittest.TestCase):
     def __init__(self, cli, method_name):
-        super(IntegrationTestBase, self).__init__(method_name)
+        super().__init__(method_name)
         self.cli = cli
         self.diagnose = os.environ.get(ENV_TEST_DIAGNOSE, None) == 'True'
 
@@ -82,7 +82,7 @@ class LiveTest(IntegrationTestBase):
 class ScenarioTest(IntegrationTestBase):  # pylint: disable=too-many-instance-attributes
 
     def __init__(self, cli, method_name, filter_headers=None):
-        super(ScenarioTest, self).__init__(cli, method_name)
+        super().__init__(cli, method_name)
         self.name_replacer = GeneralNameReplacer()
         self.recording_processors = [LargeRequestBodyProcessor(),
                                      LargeResponseBodyProcessor(),
@@ -113,7 +113,7 @@ def __init__(self, cli, method_name, filter_headers=None):
         self.original_env = os.environ.copy()
 
     def setUp(self):
-        super(ScenarioTest, self).setUp()
+        super().setUp()
 
         # set up cassette
         cm = self.vcr.use_cassette(self.recording_file)
@@ -251,7 +251,7 @@ def _in_process_execute(self, command):
             self.exit_code = self.cli.invoke(shlex.split(command), out_file=out_buffer) or 0
             self.output = out_buffer.getvalue()
         except vcr.errors.CannotOverwriteExistingCassetteException as ex:
-            raise AssertionError(ex)
+            raise AssertionError(ex) from ex
         except CliExecutionError as ex:
             if ex.exception:
                 raise ex.exception

knack/testsdk/checkers.py

@@ -63,9 +63,9 @@ def __call__(self, execution_result):
         try:
             data = execution_result.output.strip()
             assert not data or data in none_strings
-        except AssertionError:
+        except AssertionError as ex:
             raise AssertionError("Actual value '{}' != Expected value falsy (None, '', []) or "
-                                 "string in {}".format(data, none_strings))
+                                 "string in {}".format(data, none_strings)) from ex
 
 
 class StringCheck(object):  # pylint: disable=too-few-public-methods
@@ -76,9 +76,9 @@ def __call__(self, execution_result):
         try:
             result = execution_result.output.strip().strip('"')
             assert result == self.expected_result
-        except AssertionError:
+        except AssertionError as ex:
             raise AssertionError(
-                "Actual value '{}' != Expected value {}".format(result, self.expected_result))
+                "Actual value '{}' != Expected value {}".format(result, self.expected_result)) from ex
 
 
 class StringContainCheck(object):  # pylint: disable=too-few-public-methods
@@ -89,7 +89,7 @@ def __call__(self, execution_result):
         try:
             result = execution_result.output.strip('"')
             assert self.expected_result in result
-        except AssertionError:
+        except AssertionError as ex:
             raise AssertionError(
                 "Actual value '{}' doesn't contain Expected value {}".format(result,
-                                                                             self.expected_result))
+                                                                             self.expected_result)) from ex

knack/testsdk/exceptions.py

@@ -7,19 +7,18 @@
 class CliTestError(Exception):
     def __init__(self, error_message):
         message = 'An error caused by the CLI test harness failed the test: {}'
-        super(CliTestError, self).__init__(message.format(error_message))
+        super().__init__(message.format(error_message))
 
 
 class CliExecutionError(Exception):
     def __init__(self, exception):
         self.exception = exception
         message = 'The CLI throws exception {} during execution and fails the command.'
-        super(CliExecutionError, self).__init__(message.format(exception.__class__.__name__,
-                                                               exception))
+        super().__init__(message.format(exception.__class__.__name__, exception))
 
 
 class JMESPathCheckAssertionError(AssertionError):
     def __init__(self, query, expected, actual, json_data):
         message = "Query '{}' doesn't yield expected value '{}', instead the actual value " \
                   "is '{}'. Data: \n{}\n".format(query, expected, actual, json_data)
-        super(JMESPathCheckAssertionError, self).__init__(message)
+        super().__init__(message)

knack/util.py

@@ -42,8 +42,7 @@ class CtxTypeError(TypeError):
 
     def __init__(self, obj):
         from .cli import CLI
-        super(CtxTypeError, self).__init__('expected instance of {} got {}'.format(CLI.__name__,
-                                                                                   obj.__class__.__name__))
+        super().__init__('expected instance of {} got {}'.format(CLI.__name__, obj.__class__.__name__))
 
 
 class ColorizedString(object):

requirements.txt

@@ -1,9 +1,9 @@
 argcomplete==1.11.1
 colorama==0.4.3
-flake8==3.7.9
+flake8==3.8.4
 jmespath==0.9.5
 mock==4.0.1
-pylint==2.5.3
+pylint==2.6.0
 Pygments==2.5.2
 PyYAML==5.3.1
 six==1.14.0

tests/test_cli_scenarios.py

@@ -158,7 +158,7 @@ def test_should_enable_color(self, stdout_isatty_mock, stderr_isatty_mock):
     def test_init_log(self):
         class MyCLI(CLI):
             def __init__(self, **kwargs):
-                super(MyCLI, self).__init__(**kwargs)
+                super().__init__(**kwargs)
                 self.init_debug_log.append("init debug log: 6aa19a11")
                 self.init_info_log.append("init info log: b0746f58")
         cli = MyCLI()

tests/test_command_with_configured_defaults.py

@@ -41,7 +41,7 @@ def _set_up_command_table(self, required):
         class TestCommandsLoader(CLICommandsLoader):
 
             def load_command_table(self, args):
-                super(TestCommandsLoader, self).load_command_table(args)
+                super().load_command_table(args)
                 with CommandGroup(self, 'foo', '{}#{{}}'.format(__name__)) as g:
                     g.command('list', 'list_foo')
                 return self.command_table
@@ -50,7 +50,7 @@ def load_arguments(self, command):
                 with ArgumentsContext(self, 'foo') as c:
                     c.argument('my_param', options_list='--my-param',
                                configured_default='param', required=required)
-                super(TestCommandsLoader, self).load_arguments(command)
+                super().load_arguments(command)
         self.cli_ctx = DummyCLI(commands_loader_cls=TestCommandsLoader)
 
     @mock.patch.dict(os.environ, {'CLI_DEFAULTS_PARAM': 'myVal'})