preparse 0.1.0.dev2__tar.gz → 0.1.0.dev4__tar.gz

{preparse-0.1.0.dev2/src/preparse.egg-info → preparse-0.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 0.1.0.dev2
+Version: 0.1.0.dev4
 Summary: This project preparses args for further parsing later on.
 Author-email: Johannes <johannes-programming@mailfence.com>
 License: The MIT License (MIT)

{preparse-0.1.0.dev2 → preparse-0.1.0.dev4}/pyproject.toml

@@ -30,7 +30,7 @@ keywords = []
 name = "preparse"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "0.1.0.dev2"
+version = "0.1.0.dev4"
 
 [project.license]
 file = "LICENSE.txt"

{preparse-0.1.0.dev2 → preparse-0.1.0.dev4}/src/preparse/_parsing/Parsing.py

@@ -29,8 +29,22 @@ class Parsing:
         self.ans.extend(self.spec)
         self.spec.clear()
 
+    def get_nargs_for_letter(self: Self, letter: str) -> Nargs:
+        try:
+            return self.optdict["-" + letter]
+        except KeyError:
+            self.warn(
+                PreparseInvalidOptionWarning,
+                prog=self.parser.prog,
+                option=letter,
+            )
+            return Nargs.NO_ARGUMENT
+
     @functools.cached_property
     def islongonly(self: Self) -> bool:
+        # if a long option with a single hyphon exists
+        # then all options are treated as long options
+        # example: -foo
         for k in self.optdict.keys():
             if len(k) < 3:
                 continue
@@ -38,7 +52,6 @@ class Parsing:
                 continue
             if not k.startswith("-"):
                 continue
-            # example: -foo
             return True
         return False
 
@@ -51,12 +64,9 @@ class Parsing:
             option=self.ans[-1],
         )
 
-    @functools.cached_property
+    @property
     def optdict(self: Self) -> Dict[str, Nargs]:
-        ans: dict = dict()
-        for k, v in self.parser.optdict.items():
-            ans[str(k)] = Nargs(v)
-        return ans
+        return self.parser.optdict
 
     def possibilities(self: Self, opt: str) -> list[str]:
         if opt in self.optdict.keys():
@@ -71,26 +81,32 @@ class Parsing:
 
     def tick(self: Self, optn: str) -> str:
         if optn == "break":
+            # if no more options are allowed
             self.spec.extend(self.args)
             self.args.clear()
             return "break"
         arg: str = self.args.pop(0)
         if optn == "open":
+            # if a value for an option is already expected
             self.ans.append(arg)
             return "closed"
         if arg == "--":
+            # if arg is the special argument
             self.ans.append("--")
             return "break"
+        hasgroup: bool = optn == "group"
         if arg.startswith("-") and arg != "-":
-            return self.tick_opt(arg)
+            # if arg is an option
+            return self.tick_opt(arg, hasgroup=hasgroup)
         else:
-            return self.tick_pos(arg)
+            # if arg is positional
+            return self.tick_pos(arg, hasgroup=hasgroup)
 
-    def tick_opt(self: Self, arg: str) -> str:
+    def tick_opt(self: Self, arg: str, /, *, hasgroup: bool) -> str:
         if arg.startswith("--") or self.islongonly:
             return self.tick_opt_long(arg)
         else:
-            return self.tick_opt_short(arg)
+            return self.tick_opt_short(arg, hasgroup=hasgroup)
 
     def tick_opt_long(self: Self, arg: str) -> str:
         try:
@@ -135,26 +151,39 @@ class Parsing:
             else:
                 return "closed"
 
-    def tick_opt_short(self: Self, arg: str) -> str:
-        self.ans.append(arg)
-        nargs = 0
-        for i in range(1 - len(arg), 0):
-            if nargs != 0:
-                return "closed"
-            nargs = self.optdict.get("-" + arg[i])
-            if nargs is None:
-                warning = PreparseInvalidOptionWarning(
-                    prog=self.parser.prog,
-                    option=arg[i],
-                )
-                self.parser.warn(warning)
-                nargs = 0
-        if nargs == 1:
-            return "open"
-        else:
+    def tick_opt_short(self: Self, arg: str, /, *, hasgroup: bool) -> str:
+        i: int
+        a: str
+        nargs: Nargs
+        if self.parser.group != Group.MINIMIZE:
+            self.ans.append("-")
+        if (self.parser.group == Group.MAXIMIZE) and hasgroup:
+            self.ans.pop()
+        for i, a in enumerate(arg):
+            if i == 0:
+                continue
+            if self.parser.group != Group.MINIMIZE:
+                self.ans[-1] += a
+            elif a == "-":
+                self.ans[-1] += a
+            else:
+                self.ans.append("-" + a)
+            nargs = self.get_nargs_for_letter(a)
+            if nargs == Nargs.NO_ARGUMENT:
+                continue
+            value: str = arg[i + 1 :]
+            return self.tick_opt_short_nongroup(nargs=nargs, value=value)
+        return "group"
+
+    def tick_opt_short_nongroup(self: Self, *, nargs: Nargs, value: str) -> str:
+        if value:
+            self.ans[-1] += value
             return "closed"
+        if nargs == Nargs.OPTIONAL_ARGUMENT:
+            return "closed"
+        return "open"
 
-    def tick_pos(self: Self, arg: str) -> str:
+    def tick_pos(self: Self, arg: str, *, hasgroup: bool) -> str:
         self.spec.append(arg)
         if self.parser.order == Order.POSIX:
             return "break"
@@ -162,7 +191,7 @@ class Parsing:
             self.dumpspec()
             return "closed"
         else:
-            return "closed"
+            return "group" if hasgroup else "closed"
 
     def warn(self: Self, wrncls: type, /, **kwargs: Any) -> None:
         wrn: PreparseWarning = wrncls(**kwargs)

{preparse-0.1.0.dev2 → preparse-0.1.0.dev4}/src/preparse/core/PreParser.py

@@ -20,6 +20,7 @@ __all__ = ["PreParser"]
 class PreParser:
     __slots__ = (
         "_abbr",
+        "_group",
         "_optdict",
         "_order",
         "_prog",
@@ -31,6 +32,7 @@ class PreParser:
         optdict: Any = None,
         prog: Any = None,
         abbr: Any = Abbr.COMPLETE,
+        group: Any = Group.MAINTAIN,
         order: Any = Order.PERMUTE,
         warn: Callable = str,
     ) -> None:
@@ -39,6 +41,7 @@ class PreParser:
         self.optdict = optdict
         self.prog = prog
         self.abbr = abbr
+        self.group = group
         self.order = order
         self.warn = warn
 
@@ -59,6 +62,11 @@ class PreParser:
         "This method returns a copy of the current instance."
         return type(self)(**self.todict())
 
+    @makeprop()
+    def group(self: Self, value: Any) -> dict:
+        "This property decides how to approach the grouping of short options."
+        return Group(value)
+
     @makeprop()
     def optdict(self: Self, value: Any) -> dict:
         "This property gives a dictionary of options."
@@ -66,6 +74,7 @@ class PreParser:
             self._optdict.clear()
             return self._optdict
         value = dict(value)
+        value = {str(k): Nargs(v) for k, v in value.items()}
         self._optdict.clear()
         self._optdict.update(value)
         return self._optdict

{preparse-0.1.0.dev2 → preparse-0.1.0.dev4}/src/preparse/core/enums.py

@@ -9,6 +9,7 @@ from typing import *
 
 __all__ = [
     "Abbr",
+    "Group",
     "Order",
     "Nargs",
 ]
@@ -26,6 +27,12 @@ class Abbr(BaseEnum):
     COMPLETE = 2
 
 
+class Group(BaseEnum):
+    MINIMIZE = 0
+    MAXIMIZE = 1
+    MAINTAIN = 2
+
+
 class Order(BaseEnum):
     GIVEN = 0
     POSIX = 1

preparse-0.1.0.dev4/src/preparse/tests/test_max.py

@@ -0,0 +1,93 @@
+import unittest
+
+from preparse.core import Group, Order, PreParser
+
+
+class TestGroupMaximize(unittest.TestCase):
+
+    def parse(self, *, optdict, query, order=Order.GIVEN):
+        p = PreParser(order=order, group=Group.MAXIMIZE, optdict=optdict)
+        ans = p.parse_args(query)
+        self.assertEqual(list(ans), list(p.parse_args(ans)))
+        return ans
+
+    def test_basic_maximize_grouping(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0}
+        query = ["-a", "-b", "-c"]
+        solution = ["-abc"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_mixed_with_non_groupable_due_to_argument(self):
+        optdict = {"-a": 0, "-b": 1, "-c": 0}
+        query = ["-a", "-b", "val", "-c"]
+        solution = ["-ab", "val", "-c"]  # no further grouping due to -b needing arg
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_across_permuted_positionals(self):
+        optdict = {"-x": 0, "-y": 0, "-z": 0}
+        query = ["arg1", "-x", "-y", "arg2", "-z"]
+        solution = ["-xyz", "arg1", "arg2"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_stops_due_to_optional_arg(self):
+        optdict = {"-a": 0, "-b": 2, "-c": 0}
+        query = ["-a", "-b", "-c"]
+        solution = ["-ab", "-c"]  # b has optional arg, cannot group
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_preserved_if_possible(self):
+        optdict = {"-f": 0, "-g": 0, "-h": 0}
+        query = ["-f", "-g"]
+        solution = ["-fg"]  # compacted
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_multiple_clusters(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0, "-x": 0, "-y": 0}
+        query = ["-a", "-b", "-c", "arg", "-x", "-y"]
+        solution = ["-abcxy", "arg"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_multiple_clusters_given(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0, "-x": 0, "-y": 0}
+        query = ["-a", "-b", "-c", "arg", "-x", "-y"]
+        solution = ["-abc", "arg", "-xy"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.GIVEN)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_multiple_clusters_posix(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0, "-x": 0, "-y": 0}
+        query = ["-a", "-b", "-c", "arg", "-x", "-y"]
+        solution = ["-abc", "arg", "-x", "-y"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+    def test_cannot_group_across_required_arg(self):
+        optdict = {"-m": 0, "-n": 1, "-o": 0}
+        query = ["-m", "-n", "data", "-o"]
+        solution = ["-mn", "data", "-o"]  # -n prevents grouping
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouping_with_double_dash(self):
+        optdict = {"-a": 0, "-b": 0}
+        query = ["-a", "--", "-b"]
+        solution = ["-a", "--", "-b"]  # grouping not done past "--"
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_preserve_original_if_only_one(self):
+        optdict = {"-q": 0}
+        query = ["-q"]
+        solution = ["-q"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+
+if __name__ == "__main__":
+    unittest.main()

preparse-0.1.0.dev4/src/preparse/tests/test_max_1.py

@@ -0,0 +1,51 @@
+import unittest
+
+from preparse.core import Group, Order, PreParser
+
+
+class TestGroupMaximizeEdgeCases(unittest.TestCase):
+
+    def parse(self, *, optdict, query, order=Order.GIVEN):
+        p = PreParser(order=order, group=Group.MAXIMIZE, optdict=optdict)
+        ans = p.parse_args(query)
+        self.assertEqual(list(ans), list(p.parse_args(ans)))
+        return ans
+
+    def test_combine_with_gap_due_to_argument(self):
+        optdict = {"-a": 0, "-b": 1, "-c": 0, "-d": 0}
+        query = ["-a", "-b", "value", "-cd"]
+        solution = ["-ab", "value", "-cd"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_do_not_combine_across_double_dash(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0}
+        query = ["-a", "--", "-b", "-c"]
+        solution = ["-a", "--", "-b", "-c"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_combine_after_permute(self):
+        optdict = {"-x": 0, "-y": 0, "-z": 0}
+        query = ["file.txt", "-x", "-y", "-z"]
+        solution = ["-xyz", "file.txt"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_preserve_mixed_grouping_and_single(self):
+        optdict = {"-m": 0, "-n": 0, "-o": 0}
+        query = ["-m", "-no"]
+        solution = ["-mno"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_merge_respects_optional_args(self):
+        optdict = {"-a": 0, "-b": 2, "-c": 0}
+        query = ["-a", "-bopt", "-c"]
+        solution = ["-abopt", "-c"]  # -b consumes opt
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+
+if __name__ == "__main__":
+    unittest.main()

preparse-0.1.0.dev4/src/preparse/tests/test_min.py

@@ -0,0 +1,80 @@
+import unittest
+
+from preparse.core import Group, Order, PreParser
+
+
+class TestMinimizeGroupParsing(unittest.TestCase):
+
+    def parse(self, *, optdict, query):
+        p = PreParser(order=Order.GIVEN, group=Group.MINIMIZE, optdict=optdict)
+        ans = p.parse_args(query)
+        self.assertEqual(list(ans), list(p.parse_args(ans)))  # round-trip check
+        return ans
+
+    def test_simple_grouped_flags(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0}
+        query = ["-abc"]
+        solution = ["-a", "-b", "-c"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouped_with_argument_at_end(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 1}
+        query = ["-abcvalue"]
+        solution = ["-a", "-b", "-cvalue"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouped_with_argument_middle(self):
+        optdict = {"-a": 0, "-b": 1, "-c": 0}
+        query = ["-abvaluec"]
+        solution = ["-a", "-bvaluec"]  # because -b consumes "valuec"
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_multiple_grouped_chunks(self):
+        optdict = {"-x": 0, "-y": 0, "-z": 1}
+        query = ["-xy", "-zabc"]
+        solution = ["-x", "-y", "-zabc"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouped_with_nonexistent_flag(self):
+        optdict = {"-a": 0, "-b": 0}
+        query = ["-abc"]
+        # assume unknown option "-c" is preserved as-is
+        solution = ["-a", "-b", "-c"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_grouped_with_equals_sign(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 1}
+        query = ["-abc=foo"]
+        solution = ["-a", "-b", "-c=foo"]  # assuming `=foo` binds to last opt
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_mixed_with_normal_args(self):
+        optdict = {"-v": 0, "-f": 1, "-o": 2}
+        query = ["-v", "-fooutput.txt", "log.txt", "--", "file1"]
+        solution = ["-v", "-fooutput.txt", "log.txt", "--", "file1"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_double_dash_preserved(self):
+        optdict = {"-a": 0, "-b": 0}
+        query = ["-ab", "--", "-c"]
+        solution = ["-a", "-b", "--", "-c"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+    def test_repeated_grouped_options(self):
+        optdict = {"-x": 0, "-y": 0}
+        query = ["-xy", "-yx"]
+        solution = ["-x", "-y", "-y", "-x"]
+        answer = self.parse(optdict=optdict, query=query)
+        self.assertEqual(solution, answer)
+
+
+if __name__ == "__main__":
+    unittest.main()

preparse-0.1.0.dev4/src/preparse/tests/test_min_1.py

@@ -0,0 +1,103 @@
+import unittest
+
+from preparse.core import Group, Order, PreParser
+
+
+class TestMinimizeGroupParsing(unittest.TestCase):
+
+    def parse(self, *, optdict, query):
+        p = PreParser(order=Order.GIVEN, group=Group.MINIMIZE, optdict=optdict)
+        ans = p.parse_args(query)
+        self.assertEqual(list(ans), list(p.parse_args(ans)))  # round-trip check
+        return ans
+
+    def test_basic_grouping(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abc"]), ["-a", "-b", "-c"]
+        )
+
+    def test_last_option_takes_argument(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 1}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abcval"]), ["-a", "-b", "-cval"]
+        )
+
+    def test_argument_in_middle(self):
+        optdict = {"-a": 0, "-b": 1, "-c": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abvalc"]), ["-a", "-bvalc"]
+        )
+
+    def test_unknown_short_option_warning_behavior(self):
+        optdict = {"-a": 0, "-b": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abx"]), ["-a", "-b", "-x"]
+        )
+
+    def test_equals_sign_treated_as_value(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 1}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abc=foo"]), ["-a", "-b", "-c=foo"]
+        )
+
+    def test_mixed_grouped_and_separate_options(self):
+        optdict = {"-a": 0, "-b": 1, "-v": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-av", "-bvalue"]),
+            ["-a", "-v", "-bvalue"],
+        )
+
+    def test_long_option_untouched(self):
+        optdict = {"-x": 0, "--file": 1}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-x", "--file=data.txt"]),
+            ["-x", "--file=data.txt"],
+        )
+
+    def test_option_with_dash_value(self):
+        optdict = {"-c": 1}
+        self.assertEqual(self.parse(optdict=optdict, query=["-c-value"]), ["-c-value"])
+
+    def test_double_dash_terminator(self):
+        optdict = {"-a": 0, "-b": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-ab", "--", "-c"]),
+            ["-a", "-b", "--", "-c"],
+        )
+
+    def test_grouped_with_space_after(self):
+        optdict = {"-x": 1, "-y": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-xy", "val"]), ["-xy", "val"]
+        )
+
+    def test_grouped_option_last_requires_arg_followed_by_space(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 1}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abc", "VAL"]),
+            ["-a", "-b", "-c", "VAL"],
+        )
+
+    def test_unrecognized_grouped_mix(self):
+        optdict = {"-a": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abc"]), ["-a", "-b", "-c"]
+        )
+
+    def test_repeated_group_flags(self):
+        optdict = {"-v": 0, "-d": 0}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-vv", "-dd"]), ["-v", "-v", "-d", "-d"]
+        )
+
+    def test_combined_behavior_argument_and_unknown(self):
+        optdict = {"-a": 0, "-b": 1}
+        self.assertEqual(
+            self.parse(optdict=optdict, query=["-abvalue", "-c"]),
+            ["-a", "-bvalue", "-c"],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

preparse-0.1.0.dev4/src/preparse/tests/test_min_2.py

@@ -0,0 +1,83 @@
+import unittest
+
+from preparse.core import Group, Order, PreParser
+
+
+class TestPermuteAndPosixParsing(unittest.TestCase):
+
+    def parse(self, *, optdict, query, order):
+        p = PreParser(order=order, group=Group.MINIMIZE, optdict=optdict)
+        ans = p.parse_args(query)
+        self.assertEqual(list(ans), list(p.parse_args(ans)))
+        return ans
+
+    # --- PERMUTE ---
+
+    def test_permute_all_positionals_moved(self):
+        optdict = {"-a": 0, "-b": 1}
+        query = ["input.txt", "-a", "-bvalue", "config.json"]
+        solution = ["-a", "-bvalue", "input.txt", "config.json"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_permute_with_mixed_options(self):
+        optdict = {"-x": 0, "-y": 2, "-z": 0}
+        query = ["-x", "file1", "-yextra", "file2", "-z"]
+        solution = ["-x", "-yextra", "-z", "file1", "file2"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_permute_grouped_flags_and_positionals(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0}
+        query = ["data.csv", "-abc"]
+        solution = ["-a", "-b", "-c", "data.csv"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_permute_with_double_dash(self):
+        optdict = {"-v": 0, "-o": 1}
+        query = ["-v", "file1", "--", "-oout.txt"]
+        solution = ["-v", "--", "file1", "-oout.txt"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    # --- POSIX ---
+
+    def test_posix_stops_at_first_positional(self):
+        optdict = {"-x": 0, "-y": 0}
+        query = ["-x", "main.py", "-y"]
+        solution = ["-x", "main.py", "-y"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+    def test_posix_multiple_positionals(self):
+        optdict = {"-a": 0, "-b": 1}
+        query = ["-a", "input.txt", "-bval", "config.yaml"]
+        solution = ["-a", "input.txt", "-bval", "config.yaml"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+    def test_posix_double_dash_preserves_options_after(self):
+        optdict = {"-v": 0, "-d": 1}
+        query = ["file.txt", "--", "-v", "-dlog.txt"]
+        solution = ["file.txt", "--", "-v", "-dlog.txt"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+    def test_posix_with_grouped_options_then_positionals(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 0}
+        query = ["-abc", "file.txt", "-d"]
+        solution = ["-a", "-b", "-c", "file.txt", "-d"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+    def test_posix_optional_arg_ignored_after_positional(self):
+        optdict = {"-o": 2, "-v": 0}
+        query = ["-o", "input.txt", "file.txt", "-v"]
+        solution = ["-o", "input.txt", "file.txt", "-v"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+
+if __name__ == "__main__":
+    unittest.main()

preparse-0.1.0.dev4/src/preparse/tests/test_min_3.py

@@ -0,0 +1,73 @@
+import unittest
+
+from preparse.core import Group, Order, PreParser
+
+
+class TestMixedArgScenarios(unittest.TestCase):
+
+    def parse(self, *, optdict, query, order):
+        p = PreParser(order=order, group=Group.MINIMIZE, optdict=optdict)
+        ans = p.parse_args(query)
+        self.assertEqual(list(ans), list(p.parse_args(ans)))
+        return ans
+
+    def test_mix_positional_long_short_optional_args_permute(self):
+        optdict = {"-a": 0, "-b": 1, "-c": 2, "--log": 1, "--debug": 0, "--config": 2}
+        query = ["input.txt", "--log=logfile", "-acextra", "--debug", "file.csv"]
+        solution = [
+            "--log=logfile",
+            "-a",
+            "-cextra",
+            "--debug",
+            "input.txt",
+            "file.csv",
+        ]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_mix_positional_long_short_optional_args_posix(self):
+        optdict = {"-a": 0, "-b": 1, "-c": 2, "--log": 1, "--debug": 0, "--config": 2}
+        query = [
+            "--debug",
+            "-acextra",
+            "--log=logfile",
+            "input.txt",
+            "--config",
+            "settings",
+        ]
+        solution = [
+            "--debug",
+            "-a",
+            "-cextra",
+            "--log=logfile",
+            "input.txt",
+            "--config",
+            "settings",
+        ]
+        answer = self.parse(optdict=optdict, query=query, order=Order.POSIX)
+        self.assertEqual(solution, answer)
+
+    def test_optional_and_required_arg_mixed(self):
+        optdict = {"-x": 2, "-y": 1, "--mode": 2, "--file": 1}
+        query = ["-xyval", "--mode=fast", "--file", "out.txt", "input.dat"]
+        solution = ["-xyval", "--mode=fast", "--file", "out.txt", "input.dat"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.GIVEN)
+        self.assertEqual(solution, answer)
+
+    def test_long_equals_and_space_combination(self):
+        optdict = {"--alpha": 1, "--beta": 1, "-a": 0, "-b": 1}
+        query = ["--alpha=one", "--beta", "two", "-a", "-bthree", "final"]
+        solution = ["--alpha=one", "--beta", "two", "-a", "-bthree", "final"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+    def test_mix_grouped_and_non_grouped(self):
+        optdict = {"-a": 0, "-b": 0, "-c": 1, "--set": 2}
+        query = ["-abcval", "--set", "x", "y", "arg1"]
+        solution = ["-a", "-b", "-cval", "--set", "x", "y", "arg1"]
+        answer = self.parse(optdict=optdict, query=query, order=Order.PERMUTE)
+        self.assertEqual(solution, answer)
+
+
+if __name__ == "__main__":
+    unittest.main()

{preparse-0.1.0.dev2 → preparse-0.1.0.dev4/src/preparse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 0.1.0.dev2
+Version: 0.1.0.dev4
 Summary: This project preparses args for further parsing later on.
 Author-email: Johannes <johannes-programming@mailfence.com>
 License: The MIT License (MIT)

{preparse-0.1.0.dev2 → preparse-0.1.0.dev4}/src/preparse.egg-info/SOURCES.txt

@@ -25,6 +25,12 @@ src/preparse/tests/test_features.py
 src/preparse/tests/test_long_only.py
 src/preparse/tests/test_long_only_no_permutation.py
 src/preparse/tests/test_long_only_posix.py
+src/preparse/tests/test_max.py
+src/preparse/tests/test_max_1.py
+src/preparse/tests/test_min.py
+src/preparse/tests/test_min_1.py
+src/preparse/tests/test_min_2.py
+src/preparse/tests/test_min_3.py
 src/preparse/tests/test_parse.py
 src/preparse/tests/test_parse_no_permutation.py
 src/preparse/tests/test_parse_posix.py