refactor: clean up return type handling

Author: mbdevpl

argunparse/argument_unparser.py

@@ -45,78 +45,66 @@ def unparse_arg(self, arg: t.Any) -> str:  # pylint: disable = no-self-use
             arg = '""'
         return arg
 
-    def unparse_args(self, arguments: t.Sequence[t.Any],
-                     *, to_list: bool = False) -> t.Union[str, t.List[str]]:
-        """Convert list to string of command-line args."""
+    def unparse_args_to_list(self, arguments: t.Sequence[t.Any]) -> list[str]:
+        """Convert list of objects to a list of command-line args."""
         unparsed_list = []
         for arg in arguments:
             unparsed_list.append(self.unparse_arg(arg))
         _LOG.debug('%s: unparsed args to %s', self, unparsed_list)
-        if to_list:
-            return unparsed_list
-        unparsed = ' '.join(unparsed_list)
+        return unparsed_list
+
+    def unparse_args(self, arguments: t.Sequence[t.Any]) -> str:
+        """Convert list to string of command-line args."""
+        unparsed = ' '.join(self.unparse_args_to_list(arguments))
         _LOG.debug('%s: converted unparsed args to string "%s"', self, unparsed)
         return unparsed
 
-    def unparse_option(self, key: str, value: t.Any,
-                       *, to_list: bool = False) -> t.Union[str, t.List[str]]:
-        """Convert a key-value pair into a string that can be used as a command-line option."""
+    def unparse_option_to_list(self, key: str, value: t.Any) -> list[str]:
+        """Convert a key-value pair into a short list to be used as a command-line option."""
         if option_should_be_skipped(value):
-            return [] if to_list else ''
+            return []
         unparsed_key = f'{self._long_opt if len(key) > 1 else self._short_opt}{key}'
-        if not treat_as_option_with_no_value(value):
-            unparsed_value = self.unparse_arg(value)
-        if to_list and (self._opt_value == ' ' or treat_as_option_with_no_value(value)):
-            if treat_as_option_with_no_value(value):
-                return [unparsed_key]
-            return [unparsed_key, unparsed_value]
-        if not treat_as_option_with_no_value(value):
-            unparsed_option = f'{unparsed_key}{self._opt_value}{unparsed_value}'
-        if to_list:
-            return [unparsed_option]
         if treat_as_option_with_no_value(value):
-            return unparsed_key
-        return unparsed_option
+            return [unparsed_key]
+        unparsed_value = self.unparse_arg(value)
+        if self._opt_value == ' ':
+            return [unparsed_key, unparsed_value]
+        return [f'{unparsed_key}{self._opt_value}{unparsed_value}']
 
-    def unparse_options(self, options: t.Mapping[str, t.Any],
-                        *, to_list: bool = False) -> t.Union[str, t.List[str]]:
-        """Convert dictionary to string of command-line args."""
+    def unparse_option(self, key: str, value: t.Any) -> str:
+        """Convert a key-value pair into a string that can be used as a command-line option."""
+        if option_should_be_skipped(value):
+            return ''
+        unparsed = ' '.join(self.unparse_option_to_list(key, value))
+        return unparsed
+
+    def unparse_options_to_list(self, options: t.Mapping[str, t.Any]) -> list[str]:
+        """Convert dictionary to a list of command-line args."""
         unparsed_list: t.List[str] = []
         for key, value in options.items():
             if option_should_be_skipped(value):
                 continue
-            unparsed_option = self.unparse_option(key, value, to_list=to_list)
-            if to_list:
-                unparsed_list += unparsed_option
-            else:
-                assert isinstance(unparsed_option, str), type(unparsed_option)
-                unparsed_list.append(unparsed_option)
+            unparsed_list += self.unparse_option_to_list(key, value)
         _LOG.debug('%s: unparsed options to %s', self, unparsed_list)
-        if to_list:
-            return unparsed_list
-        unparsed = ' '.join(unparsed_list)
+        return unparsed_list
+
+    def unparse_options(self, options: t.Mapping[str, t.Any]) -> str:
+        """Convert dictionary to string of command-line args."""
+        unparsed = ' '.join(self.unparse_options_to_list(options))
         _LOG.debug('%s: converted unparsed options to string "%s"', self, unparsed)
         return unparsed
 
-    def unparse_options_and_args(self, options: t.Mapping[str, t.Any], arguments: t.Sequence[t.Any],
-                                 *, to_list: bool = False) -> t.Union[str, t.List[str]]:
+    def unparse_options_and_args_to_list(
+            self, options: t.Mapping[str, t.Any], arguments: t.Sequence[t.Any]) -> list[str]:
+        """Convert dictionary and list to a list of command-line args."""
+        unparsed_options = [] if options is None else self.unparse_options_to_list(options)
+        unparsed_args = [] if arguments is None else self.unparse_args_to_list(arguments)
+        return unparsed_options + unparsed_args
+
+    def unparse_options_and_args(
+            self, options: t.Mapping[str, t.Any], arguments: t.Sequence[t.Any]) -> str:
         """Convert dictionary and list to string of command-line args."""
-        if options is None:
-            unparsed_options = [] if to_list else ''
-        else:
-            unparsed_options = self.unparse_options(options, to_list=to_list)
-        if arguments is None:
-            unparsed_args = [] if to_list else ''
-        else:
-            unparsed_args = self.unparse_args(arguments, to_list=to_list)
-        if to_list:
-            return unparsed_options + unparsed_args
-        unparsed = []
-        if unparsed_options:
-            unparsed.append(unparsed_options)
-        if unparsed_args:
-            unparsed.append(unparsed_args)
-        return ' '.join(unparsed)
+        return ' '.join(self.unparse_options_and_args_to_list(options, arguments))
 
     def unparse_to_list(self, *args, **kwargs) -> list:
         """Unparse given args as command-line arguments and kwargs as command-line options.
@@ -125,7 +113,7 @@ def unparse_to_list(self, *args, **kwargs) -> list:
 
         This process is a reverse of what built-in argparse module does with parse_args() method.
         """
-        return self.unparse_options_and_args(kwargs, args, to_list=True)
+        return self.unparse_options_and_args_to_list(kwargs, args)
 
     def unparse(self, *args, **kwargs) -> str:
         """Unparse given args as command-line arguments and kwargs as command-line options.

test/test_argument_unparser.py

@@ -24,41 +24,41 @@ def test_option(self):
         for reference, option in OPTIONS.items():
             with self.subTest(option=option):
                 key, value = list(*itertools.chain(option.items()))
+                list_result = unparser.unparse_option_to_list(key, value)
+                self.assertListEqual([reference], list_result)
                 result = unparser.unparse_option(key, value)
                 self.assertEqual(reference, result)
-                list_result = unparser.unparse_option(key, value, to_list=True)
-                self.assertListEqual([reference], list_result)
 
     def test_option_skipped(self):
         unparser = ArgumentUnparser()
         for option in OPTIONS_SKIPPED.items():
             with self.subTest(option=option):
                 key, value = option
+                list_result = unparser.unparse_option_to_list(key, value)
+                self.assertListEqual(list_result, [])
                 result = unparser.unparse_option(key, value)
                 self.assertEqual(result, '')
-                list_result = unparser.unparse_option(key, value, to_list=True)
-                self.assertListEqual(list_result, [])
 
     def test_option_space(self):
         unparser = ArgumentUnparser(opt_value=' ')
         for reference, option in OPTIONS.items():
             with self.subTest(option=option):
                 key, value = list(*itertools.chain(option.items()))
+                list_result = unparser.unparse_option_to_list(key, value)
+                self.assertListEqual(reference.split('='), list_result)
                 result = unparser.unparse_option(key, value)
                 self.assertEqual(reference.replace('=', ' '), result)
-                list_result = unparser.unparse_option(key, value, to_list=True)
-                self.assertListEqual(reference.split('='), list_result)
 
     def test_options(self):
         _LOG.debug('testing %i option variants...',
                    len(OPTIONS_VARIANTS) + len(OPTIONS_SKIPPED_VARIANTS))
         unparser = ArgumentUnparser()
         for reference, options in itertools.chain(OPTIONS_VARIANTS, OPTIONS_SKIPPED_VARIANTS):
             with self.subTest(options=options):
+                list_result = unparser.unparse_options_to_list(options)
+                self.assertListEqual(reference, list_result)
                 result = unparser.unparse_options(options)
                 self.assertEqual(' '.join(reference), result)
-                list_result = unparser.unparse_options(options, to_list=True)
-                self.assertListEqual(reference, list_result)
 
     def test_options_space(self):
         _LOG.debug('testing %i option variants...',
@@ -68,7 +68,7 @@ def test_options_space(self):
             with self.subTest(options=options):
                 result = unparser.unparse_options(options)
                 self.assertEqual(' '.join(reference).replace('=', ' '), result)
-                list_result = unparser.unparse_options(options, to_list=True)
+                list_result = unparser.unparse_options_to_list(options)
                 fixed_reference = list(itertools.chain.from_iterable(
                     [_.split('=') if '=' in _ else [_] for _ in reference]))
                 self.assertListEqual(fixed_reference, list_result)
@@ -84,30 +84,30 @@ def test_args(self):
         unparser = ArgumentUnparser()
         for reference, args in ARGUMENTS_VARIANTS:
             with self.subTest(args=args):
+                list_result = unparser.unparse_args_to_list(args)
+                self.assertListEqual(reference, list_result)
                 result = unparser.unparse_args(args)
                 self.assertEqual(' '.join(reference), result)
-                list_result = unparser.unparse_args(args, to_list=True)
-                self.assertListEqual(reference, list_result)
 
     def test_options_and_args(self):
         unparser = ArgumentUnparser()
         for (reference_options, options), (reference_args, args) in OPTIONS_AND_ARGUMENTS_VARIANTS:
             with self.subTest(options=options, args=args):
+                list_result = unparser.unparse_options_and_args_to_list(None, args)
+                self.assertListEqual(reference_args, list_result)
                 result = unparser.unparse_options_and_args(None, args)
                 self.assertEqual(' '.join(reference_args), result)
-                list_result = unparser.unparse_options_and_args(None, args, to_list=True)
-                self.assertListEqual(reference_args, list_result)
 
+                list_result = unparser.unparse_options_and_args_to_list(options, None)
+                self.assertListEqual(reference_options, list_result)
                 result = unparser.unparse_options_and_args(options, None)
                 self.assertEqual(' '.join(reference_options), result)
-                list_result = unparser.unparse_options_and_args(options, None, to_list=True)
-                self.assertListEqual(reference_options, list_result)
 
+                list_result = unparser.unparse_options_and_args_to_list(options, args)
+                self.assertListEqual(reference_options + reference_args, list_result)
                 result = unparser.unparse_options_and_args(options, args)
                 self.assertEqual(
                     ' '.join(itertools.chain(reference_options, reference_args)), result)
-                list_result = unparser.unparse_options_and_args(options, args, to_list=True)
-                self.assertListEqual(reference_options + reference_args, list_result)
 
     def test_unparse(self):
         unparser = ArgumentUnparser()