superparsing 0.0.0.dev2__tar.gz → 0.2.0__tar.gz

{superparsing-0.0.0.dev2/superparsing.egg-info → superparsing-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superparsing
-Version: 0.0.0.dev2
+Version: 0.2.0
 Summary: This project does superparsing.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{superparsing-0.0.0.dev2 → superparsing-0.2.0}/pyproject.toml

@@ -27,7 +27,7 @@ license-files = [
 name = "superparsing"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "0.0.0.dev2"
+version = "0.2.0"
 
 [project.urls]
 Download = "https://pypi.org/project/superparsing/#files"

superparsing-0.2.0/src/superparsing/__init__.py

@@ -0,0 +1,6 @@
+from superparsing.core.SubCommand import SubCommand
+from superparsing.core.SuperFlag import SuperFlag
+from superparsing.core.SuperParseError import SuperParseError
+from superparsing.core.SuperParser import SuperParser
+
+__all__ = ["SuperParseError", "SuperFlag", "SubCommand", "SuperParser"]

superparsing-0.2.0/src/superparsing/core/SubCommand.py

@@ -0,0 +1,27 @@
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Self
+
+__all__ = ["SubCommand"]
+
+
+@dataclass
+class SubCommand:
+    name: object
+    aliases: Iterable[object] = ()
+    help: object = ""
+
+    def _usage(self: Self) -> str:
+        return ", ".join(map(str, [self.name] + list(self.aliases)))
+
+    def intro(self: Self) -> str:
+        ans: str
+        aliases_: list[str]
+        aliases_ = list(map(str, self.aliases))
+        ans = str(self.name)
+        if not aliases_:
+            return ans + ":"
+        ans += "("
+        ans += ", ".join(aliases_)
+        ans += "):"
+        return ans

superparsing-0.2.0/src/superparsing/core/SuperFlag.py

@@ -0,0 +1,53 @@
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Optional, Self
+
+__all__ = ["SuperFlag"]
+
+
+@dataclass
+class SuperFlag:
+    keys: Iterable[object] = ()
+    help: object = ""
+    message: Optional[object] = None
+
+    def _keys(self: Self) -> list[str]:
+        return list(map(str, self.keys))
+
+    def _message(self: Self) -> Optional[str]:
+        if self.message is None:
+            return None
+        else:
+            return str(self.message)
+
+    def _usage(self: Self) -> str:
+        ans: list[str]
+        ans = self._keys()
+        if ans:
+            return "[" + ", ".join(ans) + "]"
+        else:
+            return ""
+
+    def intro(self: Self) -> str:
+        ans: list[str]
+        ans = self._keys()
+        if ans:
+            return ", ".join(ans) + ":"
+        else:
+            return ""
+
+    def longopts(self: Self) -> tuple[str, ...]:
+        ans: list[str]
+        ans = list()
+        for flag in map(str, self.keys):
+            if flag.startswith("--"):
+                ans.append(flag[2:].split("=")[0])
+        return tuple(ans)
+
+    def shortopts(self: Self) -> str:
+        ans: str
+        ans = ""
+        for flag in map(str, self.keys):
+            if len(flag) == 2 and flag[0] == "-":
+                ans += flag[1]
+        return ans

superparsing-0.2.0/src/superparsing/core/SuperParseError.py

@@ -0,0 +1,5 @@
+__all__ = ["SuperParseError"]
+
+
+class SuperParseError(ValueError):
+    pass

superparsing-0.2.0/src/superparsing/core/SuperParser.py

@@ -0,0 +1,157 @@
+import getopt
+import importlib.metadata
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Any, Final, Optional, Self
+
+from .SubCommand import SubCommand
+from .SuperFlag import SuperFlag
+from .SuperParseError import SuperParseError
+
+__all__ = ["SuperParser"]
+
+INDENT: Final[int] = 2
+SHIFT: Final[int] = 8
+ARGS_MESSAGE: Final[str] = (
+    "These remaining args are parsed again by the chosen subcommand."
+)
+
+
+@dataclass
+class SuperParser:
+    fromfile_prefix_chars: object = field(default="", kw_only=True)
+    helpFlag: SuperFlag = field(
+        default_factory=partial(SuperFlag, help="print this message and exit"),
+        kw_only=True,
+    )
+    prog: Optional[str] = field(default=None, kw_only=True)
+    subCommands: list[SubCommand] = field(default_factory=list, kw_only=True)
+    versionFlag: SuperFlag = field(
+        default_factory=partial(SuperFlag, help="print version and exit"),
+        kw_only=True,
+    )
+
+    def _keys_message(self: Self) -> Optional[str]:
+        ans: str
+        shift: int
+        help_intro = self.helpFlag.intro()
+        version_intro = self.versionFlag.intro()
+        if help_intro + version_intro == "":
+            return None
+        ans = "keys:"
+        shift = max(SHIFT, len(help_intro), len(version_intro))
+        shift += INDENT
+        if help_intro:
+            ans += "\n"
+            ans += " " * INDENT
+            ans += help_intro.ljust(shift)
+            ans += str(self.helpFlag.help)
+        if version_intro:
+            ans += "\n"
+            ans += " " * INDENT
+            ans += version_intro.ljust(shift)
+            ans += str(self.versionFlag.help)
+        return ans
+
+    def _prog(self: Self) -> str:
+        if self.prog is None:
+            return str(sys.argv[0])
+        else:
+            return str(self.prog)
+
+    def _subCommands_message(self: Self) -> Optional[str]:
+        intros = list(map(SubCommand.intro, self.subCommands))
+        if not intros:
+            return None
+        ans = "subcommands:"
+        shift = max(SHIFT, *map(len, intros))
+        shift += INDENT
+        for intro, cmd in zip(intros, self.subCommands):
+            ans += "\n" + " " * INDENT + intro.ljust(shift) + str(cmd.help)
+        return ans
+
+    def add_subCommand(self: Self, **kwargs: Any) -> SubCommand:
+        self.subCommands.append(SubCommand(**kwargs))
+        return self.subCommands[-1]
+
+    def help(self: Self) -> str:
+        ans: list[Optional[str]]
+        intro = self.helpFlag._message()
+        if intro is not None:
+            return intro
+        ans = list()
+        ans.append(self.usage())
+        ans.append(self._keys_message())
+        ans.append(self._subCommands_message())
+        ans.append("args:\n" + " " * INDENT + ARGS_MESSAGE)
+        filtered = [part for part in ans if part is not None]
+        return "\n\n".join(filtered)
+
+    def parse_args(
+        self: Self, args: Optional[Iterable[object]] = None, /
+    ) -> list[str]:
+        args_: list[str]
+        cmd: SubCommand
+        longopts: tuple[str, ...]
+        optitems: list[tuple[str, str]]
+        shortopts: str
+        args_ = list()
+        for arg in map(str, sys.argv[1:] if args is None else args):
+            prefix_chars = str(self.fromfile_prefix_chars)
+            if arg == "" or arg[0] not in prefix_chars:
+                args_.append(arg)
+                continue
+            with open(arg[1:], "r") as stream:
+                args_.extend(stream.read().splitlines())
+        shortopts = self.helpFlag.shortopts() + self.versionFlag.shortopts()
+        longopts = self.helpFlag.longopts() + self.versionFlag.longopts()
+        try:
+            optitems, args_ = getopt.getopt(
+                args=args_, shortopts=shortopts, longopts=longopts
+            )
+        except Exception:
+            raise SuperParseError("Failed getopt!")
+        if set(self.helpFlag._keys()).intersection(dict(optitems).keys()):
+            _print(self.help())
+            return list()
+        if set(self.versionFlag._keys()).intersection(dict(optitems).keys()):
+            _print(self.version())
+            return list()
+        if not args_:
+            raise SuperParseError("Subcommand missing!")
+        for cmd in self.subCommands:
+            if args_[0] == str(cmd.name):
+                return args_
+        for cmd in self.subCommands:
+            if args_[0] in map(str, cmd.aliases):
+                args_[0] = str(cmd.name)
+                return args_
+        raise SuperParseError("Subcommand %r unknown!" % args_[0])
+
+    def usage(self: Self) -> str:
+        ans: str
+        piece: str
+        ans = "usage:"
+        ans += " " + self._prog()
+        for flag in (self.helpFlag, self.versionFlag):
+            piece = flag._usage()
+            if piece:
+                ans += " "
+                ans += piece
+        ans += " {"
+        ans += ", ".join(map(SubCommand._usage, self.subCommands))
+        ans += "} [arg ...]"
+        return ans
+
+    def version(self: Self) -> str:
+        if self.versionFlag.message is not None:
+            return str(self.versionFlag.message)
+        else:
+            return f"{self._prog()}, version {importlib.metadata.version(self._prog())}"
+
+
+def _print(value: Optional[str]) -> None:
+    if value is not None:
+        print(value)

{superparsing-0.0.0.dev2 → superparsing-0.2.0/src/superparsing.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superparsing
-Version: 0.0.0.dev2
+Version: 0.2.0
 Summary: This project does superparsing.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

superparsing-0.2.0/src/superparsing.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE.txt
+MANIFEST.in
+README.rst
+pyproject.toml
+run_tests.py
+setup.cfg
+src/superparsing/__init__.py
+src/superparsing/py.typed
+src/superparsing.egg-info/PKG-INFO
+src/superparsing.egg-info/SOURCES.txt
+src/superparsing.egg-info/dependency_links.txt
+src/superparsing.egg-info/top_level.txt
+src/superparsing/core/SubCommand.py
+src/superparsing/core/SuperFlag.py
+src/superparsing/core/SuperParseError.py
+src/superparsing/core/SuperParser.py
+src/superparsing/core/__init__.py
+tests/test_0.py
+tests/test_comprehensive_TestParseArgs.py
+tests/test_comprehensive_TestSubCommand.py
+tests/test_comprehensive_TestSuperFlag.py
+tests/test_comprehensive_TestSuperParserBasics.py
+tests/test_comprehensive_TestSuperParserText.py
+tests/test_patch.py

superparsing-0.2.0/src/superparsing.egg-info/top_level.txt

@@ -0,0 +1 @@
+superparsing

superparsing-0.2.0/tests/test_0.py

@@ -0,0 +1,94 @@
+import os
+import tempfile
+import unittest
+from typing import Self
+
+from superparsing import SubCommand, SuperFlag, SuperParseError, SuperParser
+
+
+class TestSuperFlag(unittest.TestCase):
+
+    def test_intro(self: Self) -> None:
+        flag = SuperFlag(keys=["-h", "--help"])
+        self.assertEqual(flag.intro(), "-h, --help:")
+
+    def test_shortopts(self: Self) -> None:
+        flag = SuperFlag(keys=["-h", "-v", "--help"])
+        self.assertEqual(flag.shortopts(), "hv")
+
+    def test_longopts(self: Self) -> None:
+        flag = SuperFlag(keys=["-h", "--help", "--version=1"])
+        self.assertEqual(flag.longopts(), ("help", "version"))
+
+
+class TestSubCommand(unittest.TestCase):
+
+    def test_intro_without_alias(self: Self) -> None:
+        cmd = SubCommand(name="run")
+        self.assertEqual(cmd.intro(), "run:")
+
+    def test_intro_with_aliases(self: Self) -> None:
+        cmd = SubCommand(name="run", aliases=["r", "execute"])
+        self.assertEqual(cmd.intro(), "run(r, execute):")
+
+
+class TestSuperParser(unittest.TestCase):
+
+    def setUp(self: Self) -> None:
+        self.parser = SuperParser(
+            prog="tool",
+            helpFlag=SuperFlag(keys=["-h", "--help"]),
+            versionFlag=SuperFlag(keys=["-v", "--version"]),
+        )
+        self.parser.add_subCommand(
+            name="run", aliases=["r"], help="run command"
+        )
+        self.parser.add_subCommand(name="test", help="test command")
+
+    def test_usage(self: Self) -> None:
+        usage = self.parser.usage()
+        self.assertIn("usage:", usage)
+        self.assertIn("tool", usage)
+        self.assertIn("run, r", usage)
+
+    def test_help_output(self: Self) -> None:
+        text = self.parser.help()
+        self.assertIn("usage:", text)
+        self.assertIn("subcommands:", text)
+        self.assertIn("args:", text)
+
+    def test_parse_valid_subcommand(self: Self) -> None:
+        result = self.parser.parse_args(["run"])
+        self.assertEqual(result, ["run"])
+
+    def test_parse_alias(self: Self) -> None:
+        result = self.parser.parse_args(["r"])
+        self.assertEqual(result, ["run"])
+
+    def test_parse_unknown_subcommand(self: Self) -> None:
+        with self.assertRaises(SuperParseError):
+            self.parser.parse_args(["unknown"])
+
+    def test_parse_missing_subcommand(self: Self) -> None:
+        with self.assertRaises(SuperParseError):
+            self.parser.parse_args([])
+
+    def test_version_custom_message(self: Self) -> None:
+        parser = SuperParser(
+            prog="tool", versionFlag=SuperFlag(message="custom version")
+        )
+        self.assertEqual(parser.version(), "custom version")
+
+    def test_fromfile_prefix_chars(self: Self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            fname = os.path.join(tmpdir, "a.txt")
+            with open(fname, "w") as f:
+                f.write("run\narg1\narg2")
+            parser = SuperParser(prog="tool", fromfile_prefix_chars="@")
+            parser.add_subCommand(name="run")
+            result = parser.parse_args([f"@{fname}"])
+            self.assertEqual(result, ["run", "arg1", "arg2"])
+
+
+if __name__ == "__main__":
+    unittest.main()

superparsing-0.2.0/tests/test_comprehensive_TestParseArgs.py

@@ -0,0 +1,138 @@
+import contextlib
+import io
+import os
+import sys
+import tempfile
+import unittest
+from collections.abc import Callable
+from typing import Self
+from unittest import mock
+
+from superparsing import SuperParseError, SuperParser
+
+
+def capture_stdout(
+    func: Callable[..., object],
+    *args: object,
+    **kwargs: object,
+) -> tuple[object, str]:
+    """Run ``func`` and return (return_value, captured_stdout_str)."""
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        result = func(*args, **kwargs)
+    return result, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# SuperParser: parse_args
+# ---------------------------------------------------------------------------
+class TestParseArgs(unittest.TestCase):
+    def make(self: Self) -> SuperParser:
+        p = SuperParser(prog="tool")
+        p.helpFlag.keys = ["-h", "--help"]
+        p.versionFlag.keys = ["-v", "--version"]
+        p.versionFlag.message = "tool 1.0"
+        p.add_subCommand(name="build", aliases=["b", "mk"], help="build")
+        p.add_subCommand(name="clean", help="clean")
+        return p
+
+    def test_plain_subcommand(self: Self) -> None:
+        p = self.make()
+        self.assertEqual(p.parse_args(["build"]), ["build"])
+
+    def test_subcommand_with_trailing_args(self: Self) -> None:
+        p = self.make()
+        self.assertEqual(
+            p.parse_args(["build", "--force", "target"]),
+            ["build", "--force", "target"],
+        )
+
+    def test_alias_is_rewritten_to_canonical_name(self: Self) -> None:
+        p = self.make()
+        self.assertEqual(p.parse_args(["b", "x"]), ["build", "x"])
+        self.assertEqual(p.parse_args(["mk"]), ["build"])
+
+    def test_getopt_stops_at_first_positional(self: Self) -> None:
+        # flags after the subcommand are passed through, NOT consumed as help
+        p = self.make()
+        _, out = capture_stdout(p.parse_args, ["build", "-h"])
+        # parse_args returns the list (help not triggered)
+        self.assertEqual(p.parse_args(["build", "-h"]), ["build", "-h"])
+        self.assertEqual(out, "")
+
+    def test_help_short_flag_prints_and_returns_empty(self: Self) -> None:
+        p = self.make()
+        result, out = capture_stdout(p.parse_args, ["-h"])
+        self.assertEqual(result, [])
+        self.assertIn("usage: tool", out)
+
+    def test_help_long_flag(self: Self) -> None:
+        p = self.make()
+        result, out = capture_stdout(p.parse_args, ["--help"])
+        self.assertEqual(result, [])
+        self.assertIn("subcommands:", out)
+
+    def test_version_flag_prints_and_returns_empty(self: Self) -> None:
+        p = self.make()
+        result, out = capture_stdout(p.parse_args, ["-v"])
+        self.assertEqual(result, [])
+        self.assertEqual(out.strip(), "tool 1.0")
+
+    def test_help_takes_precedence_over_version(self: Self) -> None:
+        p = self.make()
+        result, out = capture_stdout(p.parse_args, ["-v", "-h"])
+        self.assertEqual(result, [])
+        self.assertIn("usage:", out)
+        self.assertNotIn("tool 1.0", out)
+
+    def test_missing_subcommand_raises(self: Self) -> None:
+        p = self.make()
+        with self.assertRaises(SuperParseError) as ctx:
+            p.parse_args([])
+        self.assertIn("Subcommand missing", str(ctx.exception))
+
+    def test_unknown_subcommand_raises(self: Self) -> None:
+        p = self.make()
+        with self.assertRaises(SuperParseError) as ctx:
+            p.parse_args(["nope"])
+        self.assertIn("unknown", str(ctx.exception))
+
+    def test_reads_sys_argv_when_args_none(self: Self) -> None:
+        p = self.make()
+        with mock.patch.object(sys, "argv", ["tool", "clean", "now"]):
+            self.assertEqual(p.parse_args(), ["clean", "now"])
+
+    def test_non_string_args_are_coerced(self: Self) -> None:
+        p = self.make()
+        # map(str, ...) means numeric tokens are stringified before matching
+        self.assertEqual(p.parse_args(["build", 5]), ["build", "5"])
+
+    def test_fromfile_prefix_expands_file(self: Self) -> None:
+        p = self.make()
+        p.fromfile_prefix_chars = "@"
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "args.txt")
+            with open(path, "w") as fh:
+                fh.write("build\n--flag\nvalue\n")
+            self.assertEqual(
+                p.parse_args(["@" + path]),
+                ["build", "--flag", "value"],
+            )
+
+    def test_fromfile_disabled_by_default(self: Self) -> None:
+        # default fromfile_prefix_chars == "" -> "@file" treated literally
+        p = self.make()
+        with self.assertRaises(SuperParseError):
+            # "@whatever" is an unknown subcommand, not a file read
+            p.parse_args(["@whatever"])
+
+    def test_empty_string_arg_is_not_treated_as_file(self: Self) -> None:
+        p = self.make()
+        p.fromfile_prefix_chars = "@"
+        # leading "" must not crash on arg[0]; it's a positional/unknown subcmd
+        with self.assertRaises(SuperParseError):
+            p.parse_args([""])
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

superparsing-0.2.0/tests/test_comprehensive_TestSubCommand.py

@@ -0,0 +1,57 @@
+import contextlib
+import io
+import unittest
+from collections.abc import Callable
+from typing import Self
+
+from superparsing import SubCommand
+
+
+def capture_stdout(
+    func: Callable[..., object],
+    *args: object,
+    **kwargs: object,
+) -> tuple[object, str]:
+    """Run ``func`` and return (return_value, captured_stdout_str)."""
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        result = func(*args, **kwargs)
+    return result, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# SubCommand
+# ---------------------------------------------------------------------------
+class TestSubCommand(unittest.TestCase):
+    def test_defaults(self: Self) -> None:
+        c = SubCommand(name="run")
+        self.assertEqual(c.name, "run")
+        self.assertEqual(tuple(c.aliases), ())
+        self.assertEqual(c.help, "")
+
+    def test_usage_no_aliases(self: Self) -> None:
+        self.assertEqual(SubCommand(name="run")._usage(), "run")
+
+    def test_usage_with_aliases(self: Self) -> None:
+        c = SubCommand(name="build", aliases=["b", "make"])
+        self.assertEqual(c._usage(), "build, b, make")
+
+    def test_usage_coerces_non_strings(self: Self) -> None:
+        c = SubCommand(name=1, aliases=[2, 3])
+        self.assertEqual(c._usage(), "1, 2, 3")
+
+    def test_intro_no_aliases(self: Self) -> None:
+        self.assertEqual(SubCommand(name="run").intro(), "run:")
+
+    def test_intro_with_aliases(self: Self) -> None:
+        c = SubCommand(name="build", aliases=["b", "make"])
+        self.assertEqual(c.intro(), "build(b, make):")
+
+    def test_intro_single_alias(self: Self) -> None:
+        self.assertEqual(
+            SubCommand(name="build", aliases=["b"]).intro(), "build(b):"
+        )
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

superparsing-0.2.0/tests/test_comprehensive_TestSuperFlag.py

@@ -0,0 +1,88 @@
+import contextlib
+import io
+import unittest
+from collections.abc import Callable
+from typing import Self
+
+from superparsing import SuperFlag
+
+
+def capture_stdout(
+    func: Callable[..., object],
+    *args: object,
+    **kwargs: object,
+) -> tuple[object, str]:
+    """Run ``func`` and return (return_value, captured_stdout_str)."""
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        result = func(*args, **kwargs)
+    return result, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# SuperFlag
+# ---------------------------------------------------------------------------
+class TestSuperFlag(unittest.TestCase):
+    def test_defaults(self: Self) -> None:
+        f = SuperFlag()
+        self.assertEqual(tuple(f.keys), ())
+        self.assertEqual(f.help, "")
+        self.assertIsNone(f.message)
+
+    def test_keys_stringifies(self: Self) -> None:
+        f = SuperFlag(keys=["-h", "--help"])
+        self.assertEqual(f._keys(), ["-h", "--help"])
+
+    def test_keys_stringifies_non_strings(self: Self) -> None:
+        # keys is typed Iterable[object]; non-strings must be coerced via str()
+        f = SuperFlag(keys=[1, 2.5, None])
+        self.assertEqual(f._keys(), ["1", "2.5", "None"])
+
+    def test_message_none(self: Self) -> None:
+        self.assertIsNone(SuperFlag().message)
+        self.assertIsNone(SuperFlag()._message())
+
+    def test_message_coerced(self: Self) -> None:
+        self.assertEqual(SuperFlag(message=42)._message(), "42")
+        self.assertEqual(SuperFlag(message="hi")._message(), "hi")
+
+    def test_usage_with_keys(self: Self) -> None:
+        self.assertEqual(
+            SuperFlag(keys=["-h", "--help"])._usage(), "[-h, --help]"
+        )
+
+    def test_usage_empty(self: Self) -> None:
+        self.assertEqual(SuperFlag()._usage(), "")
+
+    def test_intro_with_keys(self: Self) -> None:
+        self.assertEqual(
+            SuperFlag(keys=["-h", "--help"]).intro(), "-h, --help:"
+        )
+
+    def test_intro_empty(self: Self) -> None:
+        self.assertEqual(SuperFlag().intro(), "")
+
+    def test_longopts(self: Self) -> None:
+        f = SuperFlag(keys=["-h", "--help", "--version"])
+        self.assertEqual(f.longopts(), ("help", "version"))
+
+    def test_longopts_strips_equals(self: Self) -> None:
+        f = SuperFlag(keys=["--name=VALUE"])
+        self.assertEqual(f.longopts(), ("name",))
+
+    def test_longopts_ignores_short_and_bare(self: Self) -> None:
+        f = SuperFlag(keys=["-h", "h", "help", "--x"])
+        self.assertEqual(f.longopts(), ("x",))
+
+    def test_shortopts(self: Self) -> None:
+        f = SuperFlag(keys=["-h", "-v", "--help"])
+        self.assertEqual(f.shortopts(), "hv")
+
+    def test_shortopts_ignores_long_and_malformed(self: Self) -> None:
+        f = SuperFlag(keys=["--help", "-ab", "x", "-"])
+        # only exactly "-X" (len 2, leading dash) counts
+        self.assertEqual(f.shortopts(), "")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

superparsing-0.2.0/tests/test_comprehensive_TestSuperParserBasics.py

@@ -0,0 +1,53 @@
+import contextlib
+import io
+import unittest
+from collections.abc import Callable
+from typing import Self
+
+from superparsing import SubCommand, SuperParser
+
+
+def capture_stdout(
+    func: Callable[..., object],
+    *args: object,
+    **kwargs: object,
+) -> tuple[object, str]:
+    """Run ``func`` and return (return_value, captured_stdout_str)."""
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        result = func(*args, **kwargs)
+    return result, buf.getvalue()
+
+
+class TestSuperParserBasics(unittest.TestCase):
+    def test_default_flags_have_help_text(self: Self) -> None:
+        p = SuperParser()
+        self.assertEqual(p.helpFlag.help, "print this message and exit")
+        self.assertEqual(p.versionFlag.help, "print version and exit")
+        # default flags carry no keys until the user assigns them
+        self.assertEqual(tuple(p.helpFlag.keys), ())
+        self.assertEqual(tuple(p.versionFlag.keys), ())
+
+    def test_instances_do_not_share_mutable_state(self: Self) -> None:
+        # default_factory must produce fresh objects per instance
+        p1 = SuperParser()
+        p2 = SuperParser()
+        self.assertIsNot(p1.helpFlag, p2.helpFlag)
+        self.assertIsNot(p1.versionFlag, p2.versionFlag)
+        self.assertIsNot(p1.subCommands, p2.subCommands)
+        p1.subCommands.append(SubCommand(name="x"))
+        self.assertEqual(p2.subCommands, [])
+
+    def test_add_subCommand_returns_and_appends(self: Self) -> None:
+        p = SuperParser()
+        c = p.add_subCommand(name="run", aliases=["r"], help="go")
+        self.assertIsInstance(c, SubCommand)
+        self.assertIs(p.subCommands[-1], c)
+        self.assertEqual(c.name, "run")
+
+    def test_subcommands_message_none_when_empty(self: Self) -> None:
+        self.assertIsNone(SuperParser()._subCommands_message())
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

superparsing-0.2.0/tests/test_comprehensive_TestSuperParserText.py

@@ -0,0 +1,81 @@
+import contextlib
+import io
+import unittest
+from collections.abc import Callable
+from typing import Self
+
+from superparsing import SuperParser
+
+
+def capture_stdout(
+    func: Callable[..., object],
+    *args: object,
+    **kwargs: object,
+) -> tuple[object, str]:
+    """Run ``func`` and return (return_value, captured_stdout_str)."""
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        result = func(*args, **kwargs)
+    return result, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# SuperParser: usage / help / version text
+# ---------------------------------------------------------------------------
+class TestSuperParserText(unittest.TestCase):
+    def make(self: Self) -> SuperParser:
+        p = SuperParser(prog="tool")
+        p.helpFlag.keys = ["-h", "--help"]
+        p.versionFlag.keys = ["-v", "--version"]
+        p.add_subCommand(name="build", aliases=["b"], help="build the project")
+        p.add_subCommand(name="clean", help="remove artifacts")
+        return p
+
+    def test_usage_full(self: Self) -> None:
+        p = self.make()
+        self.assertEqual(
+            p.usage(),
+            "usage: tool [-h, --help] [-v, --version] {build, b, clean} [arg ...]",
+        )
+
+    def test_usage_no_flags_no_subcommands(self: Self) -> None:
+        p = SuperParser(prog="tool")
+        self.assertEqual(p.usage(), "usage: tool {} [arg ...]")
+
+    def test_help_contains_all_sections(self: Self) -> None:
+        p = self.make()
+        h = p.help()
+        self.assertTrue(h.startswith("usage: tool"))
+        self.assertIn("keys:", h)
+        self.assertIn("subcommands:", h)
+        self.assertIn("args:", h)
+        # sections separated by blank lines
+        self.assertIn("\n\n", h)
+
+    def test_help_message_override(self: Self) -> None:
+        p = self.make()
+        p.helpFlag.message = "custom help blob"
+        self.assertEqual(p.help(), "custom help blob")
+
+    def test_help_omits_missing_sections(self: Self) -> None:
+        # no flags, no subcommands -> only usage + args sections
+        p = SuperParser(prog="tool")
+        h = p.help()
+        self.assertIn("usage:", h)
+        self.assertIn("args:", h)
+        self.assertNotIn("keys:", h)
+        self.assertNotIn("subcommands:", h)
+
+    def test_version_from_message(self: Self) -> None:
+        p = SuperParser(prog="tool")
+        p.versionFlag.message = "tool 2.3.4"
+        self.assertEqual(p.version(), "tool 2.3.4")
+
+    def test_version_message_coerced(self: Self) -> None:
+        p = SuperParser(prog="tool")
+        p.versionFlag.message = 99
+        self.assertEqual(p.version(), "99")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

superparsing-0.2.0/tests/test_patch.py

@@ -0,0 +1,29 @@
+import unittest
+from typing import Self
+from unittest.mock import MagicMock, patch
+
+from superparsing import SuperFlag, SuperParser
+
+
+class TestSuperParser(unittest.TestCase):
+
+    def setUp(self: Self) -> None:
+        self.parser = SuperParser(
+            prog="tool",
+            helpFlag=SuperFlag(keys=["-h", "--help"]),
+            versionFlag=SuperFlag(keys=["-v", "--version"]),
+        )
+        self.parser.add_subCommand(
+            name="run", aliases=["r"], help="run command"
+        )
+        self.parser.add_subCommand(name="test", help="test command")
+
+    @patch("importlib.metadata.version")
+    def test_version_default(self: Self, mock_version: MagicMock) -> None:
+        mock_version.return_value = "2.0.0"
+        parser = SuperParser(prog="tool")
+        self.assertEqual(parser.version(), "tool, version 2.0.0")
+
+
+if __name__ == "__main__":
+    unittest.main()

superparsing-0.0.0.dev2/make/env.py

@@ -1,85 +0,0 @@
-import argparse
-import json
-import subprocess
-from typing import Any, Optional
-
-__all__ = ["main", "run"]
-
-
-def env_create(env: str, python: Optional[str]) -> subprocess.CompletedProcess:  # type: ignore[type-arg]
-    args: list[str]
-    args = [
-        "conda",
-        "create",
-        "--name",
-        env,
-        "--yes",
-        "--channel",
-        "conda-forge",
-        "--override-channels",
-    ]
-    if python is not None:
-        args.append("python=" + python)
-    return subprocess.run(
-        args,
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-
-def env_list() -> list[str]:
-    ans: list[str]
-    data: Any
-    result: subprocess.CompletedProcess  # type: ignore[type-arg]
-    try:
-        result = subprocess.run(
-            ["conda", "env", "list", "--json"],
-            check=True,
-            capture_output=True,
-            text=True,
-        )
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return []
-    data = json.loads(result.stdout)
-    ans = list()
-    for details in data["envs_details"].values():
-        ans.append(str(details["name"]))
-    return ans
-
-
-def env_remove(env: str) -> subprocess.CompletedProcess:  # type: ignore[type-arg]
-    args: list[str]
-    args = ["conda", "env", "remove", "-y", "-n", env]
-    return subprocess.run(args, check=True)
-
-
-def main(args: Optional[list[str]] = None, /) -> None:
-    kwargs: dict[str, Any]
-    parser: argparse.ArgumentParser
-    parser = argparse.ArgumentParser(fromfile_prefix_chars="@")
-    # parser.add_argument("--errfile", default="-")
-    # parser.add_argument("--outfile", default="-")
-    parser.add_argument("--python")
-    parser.add_argument("--recreate", action="store_true")
-    parser.add_argument("envs", default=[], nargs="*")
-    kwargs = vars(parser.parse_args(args))
-    run(*kwargs.pop("envs"), **kwargs)
-
-
-def run(
-    *envs: str, python: Optional[str] = None, recreate: bool = False
-) -> None:
-    env: str
-    envs_: list[str]
-    envs_ = env_list()
-    for env in envs:
-        if env in envs_ and not recreate:
-            continue
-        if env in envs_:
-            env_remove(env)
-        env_create(env, python=python)
-
-
-if __name__ == "__main__":
-    main()

superparsing-0.0.0.dev2/superparsing.egg-info/SOURCES.txt

@@ -1,12 +0,0 @@
-LICENSE.txt
-MANIFEST.in
-README.rst
-pyproject.toml
-run_tests.py
-setup.cfg
-make/env.py
-superparsing.egg-info/PKG-INFO
-superparsing.egg-info/SOURCES.txt
-superparsing.egg-info/dependency_links.txt
-superparsing.egg-info/top_level.txt
-tests/test_1984.py

superparsing-0.0.0.dev2/superparsing.egg-info/top_level.txt

@@ -1 +0,0 @@
-make

superparsing-0.0.0.dev2/tests/test_1984.py

@@ -1,10 +0,0 @@
-import unittest
-
-
-class Test1984(unittest.TestCase):
-    def test_two_plus_two(self):
-        self.assertEqual(2 + 2, 4)
-
-
-if __name__ == "__main__":
-    unittest.main()