Apply some more ruff SIM automated simplifications

Author: tleonhardt

cmd2/argparse_completer.py

@@ -88,9 +88,8 @@ def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
         return False
 
     # If it looks like a negative number, it is not a flag unless there are negative-number-like flags
-    if parser._negative_number_matcher.match(token):
-        if not parser._has_negative_number_optionals:
-            return False
+    if parser._negative_number_matcher.match(token) and not parser._has_negative_number_optionals:
+        return False
 
     # Flags can't have a space
     if ' ' in token:

cmd2/argparse_custom.py

@@ -1056,10 +1056,7 @@ def _format_usage(
                 def get_lines(parts: list[str], indent: str, prefix: Optional[str] = None) -> list[str]:
                     lines: list[str] = []
                     line: list[str] = []
-                    if prefix is not None:
-                        line_len = len(prefix) - 1
-                    else:
-                        line_len = len(indent) - 1
+                    line_len = len(prefix) - 1 if prefix is not None else len(indent) - 1
                     for part in parts:
                         if line_len + 1 + len(part) > text_width and line:
                             lines.append(indent + ' '.join(line))
@@ -1172,10 +1169,7 @@ def _format_args(self, action: argparse.Action, default_metavar: Union[str, tupl
         # Handle nargs specified as a range
         nargs_range = action.get_nargs_range()  # type: ignore[attr-defined]
         if nargs_range is not None:
-            if nargs_range[1] == constants.INFINITY:
-                range_str = f'{nargs_range[0]}+'
-            else:
-                range_str = f'{nargs_range[0]}..{nargs_range[1]}'
+            range_str = f'{nargs_range[0]}+' if nargs_range[1] == constants.INFINITY else f'{nargs_range[0]}..{nargs_range[1]}'
 
             return '{}{{{}}}'.format('%s' % metavar_formatter(1), range_str)
 

cmd2/cmd2.py

@@ -50,6 +50,7 @@
 from collections.abc import Callable, Iterable, Mapping
 from contextlib import (
     redirect_stdout,
+    suppress,
 )
 from types import (
     FrameType,
@@ -689,13 +690,13 @@ def register_command_set(self, cmdset: CommandSet) -> None:
         if self.always_prefix_settables:
             if not cmdset.settable_prefix.strip():
                 raise CommandSetRegistrationError('CommandSet settable prefix must not be empty')
-            for key in cmdset.settables.keys():
+            for key in cmdset.settables:
                 prefixed_name = f'{cmdset.settable_prefix}.{key}'
                 if prefixed_name in all_settables:
                     raise CommandSetRegistrationError(f'Duplicate settable: {key}')
 
         else:
-            for key in cmdset.settables.keys():
+            for key in cmdset.settables:
                 if key in all_settables:
                     raise CommandSetRegistrationError(f'Duplicate settable {key} is already registered')
 
@@ -1098,7 +1099,7 @@ def add_settable(self, settable: Settable) -> None:
         :param settable: Settable object being added
         """
         if not self.always_prefix_settables:
-            if settable.name in self.settables.keys() and settable.name not in self._settables.keys():
+            if settable.name in self.settables and settable.name not in self._settables:
                 raise KeyError(f'Duplicate settable: {settable.name}')
         self._settables[settable.name] = settable
 
@@ -1594,10 +1595,7 @@ def index_based_complete(
 
         # Check if token is at an index in the dictionary
         match_against: Optional[Union[Iterable[str], CompleterFunc]]
-        if index in index_dict:
-            match_against = index_dict[index]
-        else:
-            match_against = all_else
+        match_against = index_dict.get(index, all_else)
 
         # Perform tab completion using a Iterable
         if isinstance(match_against, Iterable):
@@ -1739,10 +1737,7 @@ def complete_users() -> list[str]:
 
             # Remove cwd if it was added to match the text readline expects
             if cwd_added:
-                if cwd == os.path.sep:
-                    to_replace = cwd
-                else:
-                    to_replace = cwd + os.path.sep
+                to_replace = cwd if cwd == os.path.sep else cwd + os.path.sep
                 matches = [cur_path.replace(to_replace, '', 1) for cur_path in matches]
 
             # Restore the tilde string if we expanded one to match the text readline expects
@@ -1962,10 +1957,7 @@ def _display_matches_pyreadline(self, matches: list[str]) -> None:  # pragma: no
             # Otherwise use pyreadline3's formatter
             else:
                 # Check if we should show display_matches
-                if self.display_matches:
-                    matches_to_display = self.display_matches
-                else:
-                    matches_to_display = matches
+                matches_to_display = self.display_matches if self.display_matches else matches
 
                 # Add padding for visual appeal
                 matches_to_display, _ = self._pad_matches_to_display(matches_to_display)
@@ -2154,10 +2146,7 @@ def _perform_completion(
 
                 if add_quote:
                     # Figure out what kind of quote to add and save it as the unclosed_quote
-                    if any('"' in match for match in self.completion_matches):
-                        completion_token_quote = "'"
-                    else:
-                        completion_token_quote = '"'
+                    completion_token_quote = "'" if any('"' in match for match in self.completion_matches) else '"'
 
                     self.completion_matches = [completion_token_quote + match for match in self.completion_matches]
 
@@ -2762,7 +2751,7 @@ def _input_line_to_statement(self, line: str, *, orig_rl_history_length: Optiona
                 orig_rl_history_length = None
 
             # Check if this command matches a macro and wasn't already processed to avoid an infinite loop
-            if statement.command in self.macros.keys() and statement.command not in used_macros:
+            if statement.command in self.macros and statement.command not in used_macros:
                 used_macros.append(statement.command)
                 resolve_result = self._resolve_macro(statement)
                 if resolve_result is None:
@@ -2795,7 +2784,7 @@ def _resolve_macro(self, statement: Statement) -> Optional[str]:
         :param statement: the parsed statement from the command line
         :return: the resolved macro or None on error
         """
-        if statement.command not in self.macros.keys():
+        if statement.command not in self.macros:
             raise KeyError(f"{statement.command} is not a macro")
 
         macro = self.macros[statement.command]
@@ -2886,10 +2875,8 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
             # like: !ls -l | grep user | wc -l > out.txt. But this makes it difficult to know if the pipe process
             # started OK, since the shell itself always starts. Therefore, we will wait a short time and check
             # if the pipe process is still running.
-            try:
+            with suppress(subprocess.TimeoutExpired):
                 proc.wait(0.2)
-            except subprocess.TimeoutExpired:
-                pass
 
             # Check if the pipe process already exited
             if proc.returncode is not None:
@@ -3462,10 +3449,7 @@ def _alias_list(self, args: argparse.Namespace) -> None:
         tokens_to_quote = constants.REDIRECTION_TOKENS
         tokens_to_quote.extend(self.statement_parser.terminators)
 
-        if args.names:
-            to_list = utils.remove_duplicates(args.names)
-        else:
-            to_list = sorted(self.aliases, key=self.default_sort_key)
+        to_list = utils.remove_duplicates(args.names) if args.names else sorted(self.aliases, key=self.default_sort_key)
 
         not_found: list[str] = []
         for name in to_list:
@@ -3697,10 +3681,7 @@ def _macro_list(self, args: argparse.Namespace) -> None:
         tokens_to_quote = constants.REDIRECTION_TOKENS
         tokens_to_quote.extend(self.statement_parser.terminators)
 
-        if args.names:
-            to_list = utils.remove_duplicates(args.names)
-        else:
-            to_list = sorted(self.macros, key=self.default_sort_key)
+        to_list = utils.remove_duplicates(args.names) if args.names else sorted(self.macros, key=self.default_sort_key)
 
         not_found: list[str] = []
         for name in to_list:
@@ -3865,10 +3846,7 @@ def columnize(self, str_list: Optional[list[str]], display_width: int = 80) -> N
             texts = []
             for col in range(ncols):
                 i = row + nrows * col
-                if i >= size:
-                    x = ""
-                else:
-                    x = str_list[i]
+                x = "" if i >= size else str_list[i]
                 texts.append(x)
             while texts and not texts[-1]:
                 del texts[-1]
@@ -4267,10 +4245,8 @@ def _reset_py_display() -> None:
         # Delete any prompts that have been set
         attributes = ['ps1', 'ps2', 'ps3']
         for cur_attr in attributes:
-            try:
+            with suppress(KeyError):
                 del sys.__dict__[cur_attr]
-            except KeyError:
-                pass
 
         # Reset functions
         sys.displayhook = sys.__displayhook__
@@ -4982,10 +4958,7 @@ def _generate_transcript(
             self.perror(f"Error saving transcript file '{transcript_path}': {ex}")
         else:
             # and let the user know what we did
-            if commands_run == 1:
-                plural = 'command and its output'
-            else:
-                plural = 'commands and their outputs'
+            plural = 'command and its output' if commands_run == 1 else 'commands and their outputs'
             self.pfeedback(f"{commands_run} {plural} saved to transcript file '{transcript_path}'")
             self.last_result = True
 

cmd2/command_definition.py

@@ -156,11 +156,11 @@ def add_settable(self, settable: Settable) -> None:
         """
         if self.__cmd_internal is not None:
             if not self._cmd.always_prefix_settables:
-                if settable.name in self._cmd.settables.keys() and settable.name not in self._settables.keys():
+                if settable.name in self._cmd.settables and settable.name not in self._settables:
                     raise KeyError(f'Duplicate settable: {settable.name}')
             else:
                 prefixed_name = f'{self._settable_prefix}.{settable.name}'
-                if prefixed_name in self._cmd.settables.keys() and settable.name not in self._settables.keys():
+                if prefixed_name in self._cmd.settables and settable.name not in self._settables:
                     raise KeyError(f'Duplicate settable: {settable.name}')
         self._settables[settable.name] = settable
 

cmd2/history.py

@@ -114,10 +114,7 @@ def pr(self, idx: int, script: bool = False, expanded: bool = False, verbose: bo
             if raw != expanded_command:
                 ret_str += '\n' + self._ex_listformat.format(idx, expanded_command)
         else:
-            if expanded:
-                ret_str = self.expanded
-            else:
-                ret_str = single_line_format(self.statement).rstrip()
+            ret_str = self.expanded if expanded else single_line_format(self.statement).rstrip()
 
             # Display a numbered list if not writing to a script
             if not script:

cmd2/parsing.py

@@ -353,10 +353,9 @@ def is_valid_command(self, word: str, *, is_subcommand: bool = False) -> tuple[b
         errmsg += ', '.join([shlex.quote(x) for x in errchars])
 
         match = self._command_pattern.search(word)
-        if match:
-            if word == match.group(1):
-                valid = True
-                errmsg = ''
+        if match and word == match.group(1):
+            valid = True
+            errmsg = ''
         return valid, errmsg
 
     def tokenize(self, line: str) -> list[str]:
@@ -507,10 +506,7 @@ def parse(self, line: str) -> Statement:
                 arg_list = tokens[1:]
 
         # set multiline
-        if command in self.multiline_commands:
-            multiline_command = command
-        else:
-            multiline_command = ''
+        multiline_command = command if command in self.multiline_commands else ''
 
         # build the statement
         return Statement(
@@ -580,10 +576,7 @@ def parse_command_only(self, rawinput: str) -> Statement:
                 args = ''
 
         # set multiline
-        if command in self.multiline_commands:
-            multiline_command = command
-        else:
-            multiline_command = ''
+        multiline_command = command if command in self.multiline_commands else ''
 
         # build the statement
         return Statement(args, raw=rawinput, command=command, multiline_command=multiline_command)

cmd2/py_bridge.py

@@ -124,13 +124,12 @@ def __call__(self, command: str, *, echo: Optional[bool] = None) -> CommandResul
         stop = False
         try:
             self._cmd2_app.stdout = cast(TextIO, copy_cmd_stdout)
-            with redirect_stdout(cast(IO[str], copy_cmd_stdout)):
-                with redirect_stderr(cast(IO[str], copy_stderr)):
-                    stop = self._cmd2_app.onecmd_plus_hooks(
-                        command,
-                        add_to_history=self._add_to_history,
-                        py_bridge_call=True,
-                    )
+            with redirect_stdout(cast(IO[str], copy_cmd_stdout)), redirect_stderr(cast(IO[str], copy_stderr)):
+                stop = self._cmd2_app.onecmd_plus_hooks(
+                    command,
+                    add_to_history=self._add_to_history,
+                    py_bridge_call=True,
+                )
         finally:
             with self._cmd2_app.sigint_protection:
                 self._cmd2_app.stdout = cast(IO[str], copy_cmd_stdout.inner_stream)

cmd2/rl_utils.py

@@ -187,17 +187,11 @@ def rl_get_prompt() -> str:  # pragma: no cover
     """Get Readline's prompt."""
     if rl_type == RlType.GNU:
         encoded_prompt = ctypes.c_char_p.in_dll(readline_lib, "rl_prompt").value
-        if encoded_prompt is None:
-            prompt = ''
-        else:
-            prompt = encoded_prompt.decode(encoding='utf-8')
+        prompt = '' if encoded_prompt is None else encoded_prompt.decode(encoding='utf-8')
 
     elif rl_type == RlType.PYREADLINE:
         prompt_data: Union[str, bytes] = readline.rl.prompt
-        if isinstance(prompt_data, bytes):
-            prompt = prompt_data.decode(encoding='utf-8')
-        else:
-            prompt = prompt_data
+        prompt = prompt_data.decode(encoding='utf-8') if isinstance(prompt_data, bytes) else prompt_data
 
     else:
         prompt = ''
@@ -213,10 +207,7 @@ def rl_get_display_prompt() -> str:  # pragma: no cover
     """
     if rl_type == RlType.GNU:
         encoded_prompt = ctypes.c_char_p.in_dll(readline_lib, "rl_display_prompt").value
-        if encoded_prompt is None:
-            prompt = ''
-        else:
-            prompt = encoded_prompt.decode(encoding='utf-8')
+        prompt = '' if encoded_prompt is None else encoded_prompt.decode(encoding='utf-8')
         return rl_unescape_prompt(prompt)
     return rl_get_prompt()
 

cmd2/utils.py

@@ -58,10 +58,7 @@ def is_quoted(arg: str) -> bool:
 
 def quote_string(arg: str) -> str:
     """Quote a string."""
-    if '"' in arg:
-        quote = "'"
-    else:
-        quote = '"'
+    quote = "'" if '"' in arg else '"'
 
     return quote + arg + quote
 
@@ -360,10 +357,7 @@ def find_editor() -> Optional[str]:
 
         # Get a list of every directory in the PATH environment variable and ignore symbolic links
         env_path = os.getenv('PATH')
-        if env_path is None:
-            paths = []
-        else:
-            paths = [p for p in env_path.split(os.path.pathsep) if not os.path.islink(p)]
+        paths = [] if env_path is None else [p for p in env_path.split(os.path.pathsep) if not os.path.islink(p)]
 
         for possible_editor, path in itertools.product(editors, paths):
             editor_path = os.path.join(path, possible_editor)
@@ -422,10 +416,7 @@ def get_exes_in_path(starts_with: str) -> list[str]:
 
     # Get a list of every directory in the PATH environment variable and ignore symbolic links
     env_path = os.getenv('PATH')
-    if env_path is None:
-        paths = []
-    else:
-        paths = [p for p in env_path.split(os.path.pathsep) if not os.path.islink(p)]
+    paths = [] if env_path is None else [p for p in env_path.split(os.path.pathsep) if not os.path.islink(p)]
 
     # Use a set to store exe names since there can be duplicates
     exes_set = set()
@@ -558,9 +549,8 @@ def write(self, b: bytes) -> None:
             # and the bytes being written contain a new line character. This is helpful when StdSim
             # is being used to capture output of a shell command because it causes the output to print
             # to the screen more often than if we waited for the stream to flush its buffer.
-            if self.std_sim_instance.line_buffering:
-                if any(newline in b for newline in ByteBuf.NEWLINES):
-                    self.std_sim_instance.flush()
+            if self.std_sim_instance.line_buffering and any(newline in b for newline in ByteBuf.NEWLINES):
+                self.std_sim_instance.flush()
 
 
 class ProcReader:
@@ -862,10 +852,7 @@ def align_text(
     # fill characters. Instead of repeating the style characters for each fill character, we'll wrap each sequence.
     fill_char_style_begin, fill_char_style_end = fill_char.split(stripped_fill_char)
 
-    if text:
-        lines = text.splitlines()
-    else:
-        lines = ['']
+    lines = text.splitlines() if text else ['']
 
     text_buf = io.StringIO()