preparse 0.1.0.dev4__tar.gz → 0.1.0.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 0.1.0.dev4
+Version: 0.1.0.dev6
 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.dev4 → preparse-0.1.0.dev6}/pyproject.toml

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

preparse-0.1.0.dev6/src/preparse/_parsing/Item.py

@@ -0,0 +1,33 @@
+import dataclasses
+import functools
+from typing import *
+
+from preparse.core.enums import *
+from preparse.core.warnings import *
+
+__all__ = ["Item"]
+
+
+@dataclasses.dataclass
+class Item:
+    key: Optional[str] = None
+    remainder: bool | str = False
+    value: Optional[str] = None
+
+    def ishungry(self: Self) -> bool:
+        return self.remainder and (self.value is None)
+
+    def isoption(self: Self) -> bool:
+        return self.key is not None
+
+    def islong(self: Self) -> bool:
+        return self.isoption() and self.key.startswith("-")
+
+    def isgroup(self: Self) -> bool:
+        return self.isoption() and not self.key.startswith("-")
+
+    def isspecial(self: Self) -> bool:
+        return self.key is None and self.value is None
+
+    def ispositional(self: Self) -> bool:
+        return self.key is None and self.value is not None

preparse-0.1.0.dev6/src/preparse/_parsing/__init__.py

@@ -0,0 +1 @@
+from preparse._parsing.process import *

preparse-0.1.0.dev6/src/preparse/_parsing/deparse.py

@@ -0,0 +1,36 @@
+from typing import *
+
+from preparse._parsing.Item import *
+
+if TYPE_CHECKING:
+    from preparse.core.PreParser import PreParser
+__all__ = ["deparse"]
+
+
+def deparse(items: list[Item]) -> list[str]:
+    ans: str = list()
+    item: Item
+    for item in items:
+        ans += deparse_item(item)
+    return ans
+
+
+def deparse_item(item: Item) -> list[str]:
+    if item.isspecial():
+        return ["--"]
+    if item.ispositional():
+        return [item.value]
+    if item.isgroup():
+        if item.value is None:
+            return ["-" + item.key]
+        if item.remainder:
+            return ["-" + item.key + item.value]
+        else:
+            return ["-" + item.key, item.value]
+    else:
+        if item.value is None:
+            return [item.key]
+        if item.remainder:
+            return [item.key + "=" + item.value]
+        else:
+            return [item.key, item.value]

preparse-0.1.0.dev6/src/preparse/_parsing/digest.py

@@ -0,0 +1,73 @@
+from typing import *
+
+from preparse._parsing.Item import *
+from preparse.core.enums import *
+from preparse.core.warnings import *
+
+if TYPE_CHECKING:
+    from preparse.core.PreParser import PreParser
+
+__all__ = ["digest"]
+
+
+def digest(*, items: list[Item], parser: "PreParser") -> list[Item]:
+    items = list(digest_order(items=items, order=parser.order))
+    items = list(digest_group(items=items, group=parser.group))
+    return items
+
+
+def digest_group(*, items: list[Item], group: Group) -> list[Item]:
+    if group == Group.MINIMIZE:
+        return digest_group_minimize(items)
+    if group == Group.MAXIMIZE:
+        return digest_group_maximize(items)
+    return items
+
+
+def digest_group_minimize(items: list[Item]) -> list[Item]:
+    ans: list[Item] = list()
+    item: Item
+    for item in items:
+        ans += digest_group_minimize_split(item)
+    return ans
+
+
+def digest_group_minimize_split(item: Item) -> list[Item]:
+    if not item.isgroup():
+        return [item]
+    ans: list[Item] = list()
+    x: str
+    for x in item.key:
+        if x == "-":
+            ans[-1].key += "-"
+        else:
+            ans.append(Item(key=x))
+    item.key = ans[-1].key
+    ans[-1] = item
+    return ans
+
+
+def digest_group_maximize(items: list[Item]) -> list[Item]:
+    ans: list[Item] = [items.pop(0)]
+    item: Item
+    for item in items:
+        if item.isgroup() and ans[-1].isgroup() and ans[-1].value is None:
+            item.key = ans[-1].key + item.key
+            ans[-1] = item
+        else:
+            ans.append(item)
+    return ans
+
+
+def digest_order(*, items: list[Item], order: Order) -> list[Item]:
+    if order == Order.PERMUTE:
+        items.sort(key=digest_order_key)
+    return items
+
+
+def digest_order_key(item: Item):
+    if item.isoption():
+        return 0
+    if item.isspecial():
+        return 1
+    return 2

preparse-0.1.0.dev6/src/preparse/_parsing/parse.py

@@ -0,0 +1,143 @@
+from typing import *
+
+from preparse._parsing.Item import *
+from preparse.core.enums import *
+from preparse.core.warnings import *
+
+if TYPE_CHECKING:
+    from preparse.core.PreParser import PreParser
+__all__ = ["parse"]
+
+PUOW = PreparseUnrecognizedOptionWarning
+PAOW = PreparseAmbiguousOptionWarning
+PUAW = PreparseUnallowedArgumentWarning
+PIOW = PreparseInvalidOptionWarning
+PLORAW = PreparseLongOptionRequiresArgumentWarning
+PSORAW = PreparseShortOptionRequiresArgumentWarning
+
+
+def parse(*, args: list[str], parser: "PreParser") -> Generator[Any, Any, Any]:
+    broken: bool = False
+    last: Optional[Item] = None
+    for arg in args:
+        if broken:
+            # if we are in the positional-only part
+            yield Item(value=arg)
+            continue
+        if last is not None:
+            # if the last item hungers for a value
+            last.value = arg
+            last.remainder = False
+            yield last
+            last = None
+            continue
+        if arg == "--":
+            yield Item()
+            broken = True
+            continue
+        if arg == "-" or not arg.startswith("-"):
+            # if the arg is positional
+            yield Item(value=arg)
+            broken = parser.order == Order.POSIX
+            continue
+        if arg.startswith("--") or parser.islongonly:
+            last = parse_long(arg=arg, parser=parser)
+        else:
+            last = parse_group(arg=arg, parser=parser)
+        if not last.ishungry():
+            yield last
+            last = None
+    if last is None:
+        # if the last item is not starved
+        return
+    if isinstance(last.remainder, str):
+        warning: PLORAW = PLORAW(
+            prog=parser.prog,
+            option=last.remainder,
+        )
+        parser.warn(warning)
+        last.remainder = True
+    else:
+        warning: PSORAW = PSORAW(
+            prog=parser.prog,
+            option=last.key[-1],
+        )
+        parser.warn(warning)
+    yield last
+
+
+def parse_long(*, arg: str, parser: "PreParser") -> Item:
+    ans: Item = parse_long_init(arg)
+    full: str = parse_long_full(item=ans, parser=parser)
+    nargs: Nargs = parser.optdict.get(full, Nargs.NO_ARGUMENT)
+    if nargs == Nargs.NO_ARGUMENT and ans.remainder:
+        warning = PUAW(prog=parser.prog, option=full)
+        parser.warn(warning)
+    if nargs == Nargs.REQUIRED_ARGUMENT:
+        ans.remainder = True
+    if ans.remainder:
+        ans.remainder = full
+    if parser.abbr == Abbr.COMPLETE:
+        ans.key = full
+    return ans
+
+
+def parse_long_init(arg: str) -> Item:
+    if "=" not in arg:
+        return Item(key=arg)
+    ans: Item = Item(remainder=True)
+    ans.key, ans.value = arg.split("=", 1)
+    return ans
+
+
+def parse_long_full(*, item: Item, parser: "PreParser") -> str:
+    if item.key in parser.optdict.keys():
+        return item.key
+    if parser.abbr == Abbr.REJECT:
+        warning: PUOW = PUOW(prog=parser.prog, option=arg)
+        parser.warn(warning)
+    x: str
+    pos: list[str] = list()
+    for x in parser.optdict.keys():
+        if x.startswith(item.key):
+            pos.append(x)
+    if len(pos) == 1:
+        return pos[0]
+    arg: str = item.key
+    if item.remainder:
+        arg += "=" + item.value
+    if len(pos) == 0:
+        warning: PUOW = PUOW(prog=parser.prog, option=arg)
+        parser.warn(warning)
+    else:
+        warning: PAOW = PAOW(prog=parser.prog, option=arg, possibilities=pos)
+        parser.warn(warning)
+    return item.key
+
+
+def parse_group_letter(letter: str, *, parser: "PreParser") -> Nargs:
+    try:
+        return parser.optdict["-" + letter]
+    except KeyError:
+        warning: PIOW = PIOW(prog=parser.prog, option=letter)
+        parser.warn(warning)
+        return Nargs.NO_ARGUMENT
+
+
+def parse_group(*, arg: str, parser: "PreParser") -> Item:
+    ans: Item = Item(key="")
+    nargs: Nargs
+    for i, a in enumerate(arg):
+        if i == 0:
+            continue
+        ans.key += a
+        nargs = parse_group_letter(a, parser=parser)
+        if nargs == Nargs.NO_ARGUMENT:
+            continue
+        if nargs == Nargs.OPTIONAL_ARGUMENT or i < len(arg) - 1:
+            ans.remainder = True
+            ans.value = arg[i + 1 :]
+        else:
+            ans.remainder = nargs == Nargs.REQUIRED_ARGUMENT
+        return ans
+    return ans

preparse-0.1.0.dev6/src/preparse/_parsing/process.py

@@ -0,0 +1,28 @@
+import sys
+from typing import *
+
+from preparse._parsing.deparse import *
+from preparse._parsing.digest import *
+from preparse._parsing.Item import *
+from preparse._parsing.parse import *
+
+if TYPE_CHECKING:
+    from preparse.core.PreParser import PreParser
+
+__all__ = ["process"]
+
+
+def process(
+    *,
+    args: Optional[Iterable] = None,
+    parser: "PreParser",
+) -> list[str]:
+    "This method parses args."
+    if args is None:
+        args = sys.argv[1:]
+    args = [str(a) for a in args]
+    parser = parser.copy()
+    items: list[Item] = list(parse(args=args, parser=parser))
+    items: list[Item] = list(digest(items=items, parser=parser))
+    ans: list[str] = list(deparse(items=items))
+    return ans

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

@@ -9,7 +9,7 @@ from datarepr import datarepr
 from makeprop import makeprop
 from tofunc import tofunc
 
-from preparse._parsing.Parsing import *
+from preparse._parsing import *
 from preparse.core.Click import *
 from preparse.core.enums import *
 
@@ -21,6 +21,7 @@ class PreParser:
     __slots__ = (
         "_abbr",
         "_group",
+        "_longonly",
         "_optdict",
         "_order",
         "_prog",
@@ -33,6 +34,7 @@ class PreParser:
         prog: Any = None,
         abbr: Any = Abbr.COMPLETE,
         group: Any = Group.MAINTAIN,
+        longonly: Any = Longonly.INFER,
         order: Any = Order.PERMUTE,
         warn: Callable = str,
     ) -> None:
@@ -42,6 +44,7 @@ class PreParser:
         self.prog = prog
         self.abbr = abbr
         self.group = group
+        self.longonly = longonly
         self.order = order
         self.warn = warn
 
@@ -67,6 +70,28 @@ class PreParser:
         "This property decides how to approach the grouping of short options."
         return Group(value)
 
+    @property
+    def islongonly(self) -> bool:
+        if self.longonly != Longonly.INFER:
+            return bool(self.longonly)
+        # 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
+            if k.startswith("--"):
+                continue
+            if not k.startswith("-"):
+                continue
+            return True
+        return False
+
+    @makeprop()
+    def longonly(self: Self, value: Any) -> Longonly:
+        "This property decides whether the parser treats all options as long."
+        return Longonly(value)
+
     @makeprop()
     def optdict(self: Self, value: Any) -> dict:
         "This property gives a dictionary of options."
@@ -84,12 +109,7 @@ class PreParser:
         args: Optional[Iterable] = None,
     ) -> list[str]:
         "This method parses args."
-        if args is None:
-            args = sys.argv[1:]
-        return Parsing(
-            parser=self.copy(),
-            args=[str(a) for a in args],
-        ).ans
+        return process(args=args, parser=self)
 
     @makeprop()
     def order(self: Self, value: Any) -> Order:

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

@@ -10,6 +10,7 @@ from typing import *
 __all__ = [
     "Abbr",
     "Group",
+    "Longonly",
     "Order",
     "Nargs",
 ]
@@ -33,6 +34,18 @@ class Group(BaseEnum):
     MAINTAIN = 2
 
 
+class Longonly(BaseEnum):
+    NO = 0
+    YES = 1
+    INFER = 2
+
+
+class Nargs(BaseEnum):
+    NO_ARGUMENT = 0
+    REQUIRED_ARGUMENT = 1
+    OPTIONAL_ARGUMENT = 2
+
+
 class Order(BaseEnum):
     GIVEN = 0
     POSIX = 1
@@ -49,9 +62,3 @@ class Order(BaseEnum):
     @classmethod
     def infer_permute(cls: type) -> Self:
         return cls.POSIX if cls._infer() else cls.PERMUTE
-
-
-class Nargs(BaseEnum):
-    NO_ARGUMENT = 0
-    REQUIRED_ARGUMENT = 1
-    OPTIONAL_ARGUMENT = 2

{preparse-0.1.0.dev4 → preparse-0.1.0.dev6}/src/preparse/core/warnings.py

@@ -4,7 +4,8 @@ from typing import *
 __all__ = [
     "PreparseAmbiguousOptionWarning",
     "PreparseInvalidOptionWarning",
-    "PreparseRequiredArgumentWarning",
+    "PreparseLongOptionRequiresArgumentWarning",
+    "PreparseShortOptionRequiresArgumentWarning",
     "PreparseUnallowedArgumentWarning",
     "PreparseUnrecognizedOptionWarning",
     "PreparseWarning",
@@ -51,7 +52,15 @@ class PreparseInvalidOptionWarning(PreparseWarning):
         return "invalid option -- %r" % self.option
 
 
-class PreparseRequiredArgumentWarning(PreparseWarning):
+class PreparseLongOptionRequiresArgumentWarning(PreparseWarning):
+    __slots__ = ("prog", "option")
+
+    def getmsg(self: Self) -> str:
+        "This method returns the core message."
+        return "option %r requires an argument" % self.option
+
+
+class PreparseShortOptionRequiresArgumentWarning(PreparseWarning):
     __slots__ = ("prog", "option")
 
     def getmsg(self: Self) -> str:

preparse-0.1.0.dev6/src/preparse/tests/test_data_toml.py

@@ -0,0 +1,35 @@
+import tomllib
+import unittest
+from importlib import resources
+
+from preparse.core import *
+
+# Read URL of the Real Python feed from config file
+
+
+class TestDataToml(unittest.TestCase):
+
+    def get_data(self):
+        text: str = resources.read_text("preparse.tests", "data.toml")
+        data: dict = tomllib.loads(text)
+        return data
+
+    def test_0(self):
+        data: dict = self.get_data()
+        data = data["data"]
+        for kwargs in data:
+            self.parse(**kwargs)
+
+    def parse(
+        self,
+        *,
+        query,
+        solution,
+        **kwargs,
+    ):
+        parser = PreParser(**kwargs)
+        msg: str = "parser=%r, query=%r" % (parser, query)
+        answer = parser.parse_args(query)
+        superanswer = parser.parse_args(answer)
+        self.assertEqual(answer, superanswer, msg=msg)
+        self.assertEqual(answer, solution, msg=msg)

{preparse-0.1.0.dev4 → preparse-0.1.0.dev6}/src/preparse/tests/test_warn_9001.py

@@ -74,7 +74,7 @@ class TestPreParserWarnings(unittest.TestCase):
         warnings_caught = self.parse_with_warning(optdict, query)
         self.assertTrue(
             any(
-                "option requires an argument -- '--foo'" in str(warning.message)
+                "option '--foo' requires an argument" in str(warning.message)
                 for warning in warnings_caught
             )
         )

{preparse-0.1.0.dev4 → preparse-0.1.0.dev6}/src/preparse/tests/test_warn_9002.py

@@ -98,7 +98,7 @@ class TestPreParserWarnings(unittest.TestCase):
         warnings_caught = self.parse_with_warning(optdict, query)
         self.assertTrue(
             any(
-                "option requires an argument -- '--foo'" in str(warning.message)
+                "option '--foo' requires an argument" in str(warning.message)
                 for warning in warnings_caught
             )
         )

{preparse-0.1.0.dev4 → preparse-0.1.0.dev6}/src/preparse/tests/test_warn_even_more.py

@@ -74,7 +74,7 @@ class TestPreParserWarnings(unittest.TestCase):
         warnings_caught = self.parse_with_warning(optdict, query)
         self.assertTrue(
             any(
-                "option requires an argument -- '--foo'" in str(warning.message)
+                "option '--foo' requires an argument" in str(warning.message)
                 for warning in warnings_caught
             )
         )

{preparse-0.1.0.dev4 → preparse-0.1.0.dev6}/src/preparse/tests/test_warn_more.py

@@ -62,7 +62,7 @@ class TestPreParserWarnings(unittest.TestCase):
         warnings_caught = self.parse_with_warning(optdict, query)
         self.assertTrue(
             any(
-                "option requires an argument -- '--foo'" in str(warning.message)
+                "option '--foo' requires an argument" in str(warning.message)
                 for warning in warnings_caught
             )
         )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 0.1.0.dev4
+Version: 0.1.0.dev6
 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.dev4 → preparse-0.1.0.dev6}/src/preparse.egg-info/SOURCES.txt

@@ -9,31 +9,21 @@ src/preparse.egg-info/SOURCES.txt
 src/preparse.egg-info/dependency_links.txt
 src/preparse.egg-info/requires.txt
 src/preparse.egg-info/top_level.txt
-src/preparse/_parsing/Parsing.py
+src/preparse/_parsing/Item.py
 src/preparse/_parsing/__init__.py
+src/preparse/_parsing/deparse.py
+src/preparse/_parsing/digest.py
+src/preparse/_parsing/parse.py
+src/preparse/_parsing/process.py
 src/preparse/core/Click.py
 src/preparse/core/PreParser.py
 src/preparse/core/__init__.py
 src/preparse/core/enums.py
 src/preparse/core/warnings.py
 src/preparse/tests/__init__.py
+src/preparse/tests/test_data_toml.py
 src/preparse/tests/test_expit.py
-src/preparse/tests/test_extra.py
-src/preparse/tests/test_extra_no_permutation.py
-src/preparse/tests/test_extra_posix.py
 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
 src/preparse/tests/test_warn_9001.py
 src/preparse/tests/test_warn_9002.py
 src/preparse/tests/test_warn_9005.py