preparse 2.0.0.dev5__tar.gz → 2.0.0.dev7__tar.gz

{preparse-2.0.0.dev5/src/preparse.egg-info → preparse-2.0.0.dev7}/PKG-INFO

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

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/docs/v1.0.rst

@@ -64,7 +64,7 @@ Features
 The PreParser class
 ~~~~~~~~~~~~~~~~~~~
 
-``class preparse.PreParser(*, allowslong: Any = True, allowsshort: Any = True, bundling: Any = Tuning.MAINTAIN, expandsabbr: Any = True, expectsabbr: Any = True, expectsposix: Any = False, optDict: Any = (), prog: Any = None, reconcilesorders: Any = True, special: Any = preparse.Tuning.MAINTAIN, warn: Callable = str)``
+``class preparse.PreParser(*, allowslong: Any = True, allowsshort: Any = True, bundling: Any = Tuning.MAINTAIN, expandsabbr: Any = True, expectsabbr: Any = True, expectsposix: Any = False, optdict: Any = (), prog: Any = None, reconcilesorders: Any = True, special: Any = preparse.Tuning.MAINTAIN, warn: Callable = str)``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This class is the centerpiece of the preparse. Its behaviour follows the principles of getopt from C.
@@ -109,7 +109,7 @@ This boolean property determines whether abbreviations of long options are expec
 
 This boolean property determines whether the order of arguments to conform to the POSIX standard, i.e. all arguments after the first positional argument also being positonal.
 
-``optDict: preparse.OptDict``
+``optdict: preparse.Optdict``
 """""""""""""""""""""""""""""
 
 This property holds a dict-like object. 
@@ -143,7 +143,7 @@ POSIX and the interleaving of options with positonal arguments, should be enforc
 """""""""""""""""""""""""""""""""""""""""""""""""""
 
 This method alters the current instance to reflect a ``click.Command`` object. 
-Concretely the optDict property is changed.
+Concretely the optdict property is changed.
 
 ``reflectClickContext(ctx: click.Context) -> None``
 """""""""""""""""""""""""""""""""""""""""""""""""""
@@ -202,15 +202,15 @@ This property determines if the ``reflectClickContext`` method of parser is to b
 
 This property holds the parser to be embedded.
 
-The OptDict class
+The Optdict class
 ~~~~~~~~~~~~~~~~~
 
-``class preparse.OptDict``
+``class preparse.Optdict``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This class is a subclass of ``datahold.HoldDict[str, preparse.Nargs]``
 with strings as keys and with ``preparse.Nargs`` as values.
-It is designed for ``preparse.PreParser.optDict``.
+It is designed for ``preparse.PreParser.optdict``.
 
 The Enums
 ~~~~~~~~~

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/pyproject.toml

@@ -34,7 +34,7 @@ keywords = []
 name = "preparse"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "2.0.0.dev5"
+version = "2.0.0.dev7"
 
 [project.license]
 file = "LICENSE.txt"

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_items/Bundle.py

@@ -5,7 +5,7 @@ import setdoc
 from preparse._items.Item import Item
 from preparse._items.Option import Option
 from preparse._utils.dataprop import dataprop
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["Bundle"]
 
@@ -32,7 +32,7 @@ class Bundle(Option):
         self.right = right
 
     @classmethod
-    def _split_allowsLong(cls: type, chars: str) -> list[str]:
+    def _split_allowslong(cls: type, chars: str) -> list[str]:
         ans: list[str]
         x: str
         ans = list()
@@ -73,12 +73,12 @@ class Bundle(Option):
         else:
             return ["-" + self.chars, self.right]
 
-    def split(self: Self, *, allowsLong: bool) -> list[Item]:
+    def split(self: Self, *, allowslong: bool) -> list[Item]:
         ans: list[Self]
         parts: list[str]
         x: str
-        if allowsLong:
-            parts = self._split_allowsLong(self.chars)
+        if allowslong:
+            parts = self._split_allowslong(self.chars)
         else:
             parts = self._split_shortonly(self.chars)
         ans = list()

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_items/Item.py

@@ -4,7 +4,7 @@ from typing import *
 import setdoc
 from copyable import Copyable
 
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["Item"]
 

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_items/Long.py

@@ -5,7 +5,7 @@ import setdoc
 
 from preparse._items.Option import Option
 from preparse._utils.dataprop import dataprop
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["Long"]
 

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_items/Option.py

@@ -3,7 +3,7 @@ from typing import *
 
 from preparse._items.Item import Item
 from preparse._utils.dataprop import dataprop
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["Option"]
 

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_items/Positional.py

@@ -4,7 +4,7 @@ import setdoc
 
 from preparse._items.Item import Item
 from preparse._utils.dataprop import dataprop
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["Positional"]
 

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_items/Special.py

@@ -1,7 +1,7 @@
 from typing import *
 
 from preparse._items.Item import Item
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["Special"]
 

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_processing/__init__.py

@@ -7,7 +7,7 @@ from preparse._processing.digesting import *
 from preparse._processing.parsing import *
 from preparse._processing.pulling import *
 from preparse._utils import *
-from preparse.enums import *
+from preparse.core.enums import *
 
 __all__ = ["process"]
 
@@ -15,15 +15,15 @@ __all__ = ["process"]
 def process(
     args: Optional[Iterable] = None,
     *,
-    allowsLong: bool,
-    allowsShort: bool,
+    allowslong: bool,
+    allowsshort: bool,
     bundling: Tuning,
     expandsabbr: bool,
     expectsabbr: bool,
-    expectsPOSIX: bool,
-    optDict: dict,
+    expectsposix: bool,
+    optdict: dict,
     prog: str,
-    reconcilesOrders: bool,
+    reconcilesorders: bool,
     special: Tuning,
     warn: FunctionType,
 ) -> list[str]:
@@ -32,21 +32,21 @@ def process(
     items = pull(args)
     items = parse(
         items,
-        allowsLong=allowsLong,
-        allowsShort=allowsShort,
+        allowslong=allowslong,
+        allowsshort=allowsshort,
+        expandsabbr=expandsabbr,
         expectsabbr=expectsabbr,
-        expectsPOSIX=expectsPOSIX,
-        optDict=optDict,
+        expectsposix=expectsposix,
+        optdict=optdict,
         prog=prog,
         warn=warn,
     )
     items = digest(
         items,
-        allowsLong=allowsLong,
+        allowslong=allowslong,
         bundling=bundling,
-        expandsabbr=expandsabbr,
-        expectsPOSIX=expectsPOSIX,
-        reconcilesOrders=reconcilesOrders,
+        expectsposix=expectsposix,
+        reconcilesorders=reconcilesorders,
         special=special,
     )
     return deparse(items)

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_processing/digesting.py

@@ -2,11 +2,11 @@ from typing import *
 
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
-from preparse._items.Long import Long
 from preparse._items.Option import Option
 from preparse._items.Positional import Positional
 from preparse._items.Special import Special
-from preparse.enums import *
+from preparse.core.enums import *
+from preparse.core.warnings import *
 
 __all__ = ["digest"]
 
@@ -14,62 +14,42 @@ __all__ = ["digest"]
 def digest(
     items: list[Item],
     *,
-    allowsLong: bool,
+    allowslong: bool,
     bundling: Tuning,
-    expandsabbr: bool,
-    expectsPOSIX: bool,
-    reconcilesOrders: bool,
+    expectsposix: bool,
+    reconcilesorders: bool,
     special: Tuning,
 ) -> list[Item]:
     ans: list[Item]
     ans = list(items)
-    ans = digest_abbr(
-        ans,
-        expandsabbr=expandsabbr,
-    )
+
     ans = digest_special(
         ans,
-        expectsPOSIX=expectsPOSIX,
-        reconcilesOrders=reconcilesOrders,
+        expectsposix=expectsposix,
+        reconcilesorders=reconcilesorders,
         special=special,
     )
     ans = digest_order(
         ans,
-        expectsPOSIX=expectsPOSIX,
-        reconcilesOrders=reconcilesOrders,
+        expectsposix=expectsposix,
+        reconcilesorders=reconcilesorders,
     )
     ans = digest_bundling(
         ans,
         bundling=bundling,
-        allowsLong=allowsLong,
+        allowslong=allowslong,
     )
     return ans
 
 
-def digest_abbr(
-    items: list[Item],
-    *,
-    expandsabbr: bool,
-) -> list[Item]:
-    ans: list[Item]
-    item: Item
-    ans = list(items)
-    if not expandsabbr:
-        return ans
-    for item in ans:
-        if isinstance(item, Long):
-            item.abbrlen = None
-    return ans
-
-
 def digest_bundling(
     items: list[Item],
     *,
-    allowsLong: bool,
+    allowslong: bool,
     bundling: Tuning,
 ) -> list[Item]:
     if bundling == Tuning.MINIMIZE:
-        return digest_bundling_min(items, allowsLong=allowsLong)
+        return digest_bundling_min(items, allowslong=allowslong)
     if bundling == Tuning.MAXIMIZE:
         return digest_bundling_max(items)
     return items
@@ -78,14 +58,14 @@ def digest_bundling(
 def digest_bundling_min(
     items: list[Item],
     *,
-    allowsLong: bool,
+    allowslong: bool,
 ) -> list[Item]:
     ans: list[Item]
     item: Item
     ans = list()
     for item in items:
         if isinstance(item, Bundle):
-            ans += item.split(allowsLong=allowsLong)
+            ans += item.split(allowslong=allowslong)
         else:
             ans.append(item)
     return ans
@@ -116,16 +96,16 @@ def digest_bundling_max(items: list[Item]) -> list[Item]:
 def digest_order(
     items: list[Item],
     *,
-    expectsPOSIX: bool,
-    reconcilesOrders: bool,
+    expectsposix: bool,
+    reconcilesorders: bool,
 ) -> list[Item]:
     ans: list[Item]
     comp: bool
     index: int
     ans = list(items)
-    if not reconcilesOrders:
+    if not reconcilesorders:
         return ans
-    if not expectsPOSIX:
+    if not expectsposix:
         ans.sort(key=digest_order_key)
         return ans
     index = len(ans)
@@ -187,8 +167,8 @@ def digest_special_max(items: list[Item]) -> list[Item]:
 def digest_special_min(
     items: list[Item],
     *,
-    expectsPOSIX: bool,
-    reconcilesOrders: bool,
+    expectsposix: bool,
+    reconcilesorders: bool,
 ) -> list[Item]:
     ans: list[Item]
     index: int
@@ -196,7 +176,7 @@ def digest_special_min(
     isposix: bool
     ans = list(items)
     isdel = True
-    isposix = expectsPOSIX and not reconcilesOrders
+    isposix = expectsposix and not reconcilesorders
     index = len(items)
     while True:
         index -= 1

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/_processing/parsing.py

@@ -7,14 +7,16 @@ from preparse._items.Long import Long
 from preparse._items.Option import Option
 from preparse._items.Positional import Positional
 from preparse._items.Special import Special
-from preparse.enums import *
-from preparse.warners.AmbiguousOptionWarner import AmbiguousOptionWarner as PAOW
-from preparse.warners.InvalidOptionWarner import InvalidOptionWarner as PIOW
-from preparse.warners.RequiredArgumentWarner import RequiredArgumentWarner as PRAW
-from preparse.warners.UnallowedArgumentWarner import UnallowedArgumentWarner as PUAW
+from preparse.core import warnings
+from preparse.core.enums import *
 
 __all__ = ["parse"]
 
+PAOW = warnings.PreparseAmbiguousOptionWarning
+PIOW = warnings.PreparseInvalidOptionWarning
+PUAW = warnings.PreparseUnallowedArgumentWarning
+PRAW = warnings.PreparseRequiredArgumentWarning
+
 
 def parse(args: list[str], **kwargs: Any) -> list[Item]:
     return list(parse_generator(args, **kwargs))
@@ -24,7 +26,7 @@ def parse_bundling(
     arg: str,
     *,
     cause: FunctionType,
-    optDict: dict,
+    optdict: dict,
 ) -> Bundle:
     ans: Bundle
     x: int
@@ -35,7 +37,7 @@ def parse_bundling(
             continue
         ans.chars += y
         try:
-            ans.nargs = optDict["-" + y]
+            ans.nargs = optdict["-" + y]
         except KeyError:
             cause(PIOW, option=y, islong=False)
             ans.nargs = Nargs.NO_ARGUMENT
@@ -62,11 +64,12 @@ def parse_cause(
 def parse_generator(
     items: list[Positional],
     *,
-    allowsLong: bool,
-    allowsShort: bool,
+    allowslong: bool,
+    allowsshort: bool,
+    expandsabbr: bool,
     expectsabbr: bool,
-    expectsPOSIX: bool,
-    optDict: dict,
+    expectsposix: bool,
+    optdict: dict,
     prog: str,
     warn: FunctionType,
 ) -> Generator[Any, Any, Any]:
@@ -74,7 +77,7 @@ def parse_generator(
     cause: FunctionType
     last: Optional[Option]
     item: Positional
-    broken = not (allowsLong or allowsShort)
+    broken = not (allowslong or allowsshort)
     cause = parse_cause(prog=prog, warn=warn)
     last = None
     for item in items:
@@ -96,15 +99,16 @@ def parse_generator(
         if item.isobvious():
             # if the item is positional
             yield item
-            broken = expectsPOSIX
+            broken = expectsposix
             continue
         last = parse_option(
             item.value,
-            allowsLong=allowsLong,
-            allowsShort=allowsShort,
+            allowslong=allowslong,
+            allowsshort=allowsshort,
             cause=cause,
+            expandsabbr=expandsabbr,
             expectsabbr=expectsabbr,
-            optDict=optDict,
+            optdict=optdict,
         )
         if not last.ishungry():
             yield last
@@ -122,21 +126,22 @@ def parse_generator(
 def parse_islong(
     arg: str,
     *,
-    allowsLong: bool,
-    allowsShort: bool,
+    allowslong: bool,
+    allowsshort: bool,
 ) -> bool:
-    if allowsLong and allowsShort:
+    if allowslong and allowsshort:
         return arg.startswith("--")
     else:
-        return not allowsShort
+        return not allowsshort
 
 
 def parse_long(
     arg: str,
     *,
     cause: FunctionType,
+    expandsabbr: bool,
     expectsabbr: bool,
-    optDict: dict,
+    optdict: dict,
 ) -> Long:
     ans: Long
     parts: list[str]
@@ -146,13 +151,10 @@ def parse_long(
         ans.joined = True
         ans.right = parts.pop()
     ans.abbrlen = len(ans.fullkey)
-    if ans.fullkey in optDict.keys():
-        ans.nargs = optDict[ans.fullkey]
-        if (ans.nargs == Nargs.NO_ARGUMENT) and (ans.right is not None):
-            cause(PUAW, option=ans.fullkey)
-        return ans
-    if expectsabbr:
-        parts = parse_long_startswith(ans.abbr, keys=optDict.keys())
+    if ans.fullkey in optdict.keys():
+        parts = [ans.fullkey]
+    elif expectsabbr:
+        parts = parse_long_startswith(ans.abbr, keys=optdict.keys())
     else:
         parts = list()  # can be assumed
     if len(parts) == 0:
@@ -164,7 +166,11 @@ def parse_long(
         cause(PAOW, option=arg, possibilities=parts)
         return ans
     (ans.fullkey,) = parts
-    ans.nargs = optDict[ans.fullkey]
+    if expandsabbr:
+        ans.abbrlen = len(ans.fullkey)
+    ans.nargs = optdict[ans.fullkey]
+    if (ans.nargs == Nargs.NO_ARGUMENT) and (ans.right is not None):
+        cause(PUAW, option=ans.fullkey)
     return ans
 
 
@@ -186,20 +192,22 @@ def parse_option(
     arg: str,
     *,
     cause: FunctionType,
+    expandsabbr: bool,
     expectsabbr: bool,
-    optDict: dict,
+    optdict: dict,
     **kwargs: Any,
 ) -> Option:
     if parse_islong(arg, **kwargs):
         return parse_long(
             arg,
             cause=cause,
+            expandsabbr=expandsabbr,
             expectsabbr=expectsabbr,
-            optDict=optDict,
+            optdict=optdict,
         )
     else:
         return parse_bundling(
             arg,
             cause=cause,
-            optDict=optDict,
+            optdict=optdict,
         )

{preparse-2.0.0.dev5 → preparse-2.0.0.dev7}/src/preparse/core/Optdict.py

@@ -6,12 +6,13 @@ import setdoc
 from datarepr import datarepr
 from frozendict import frozendict
 
-from preparse.enums import *
+from preparse.core.enums import *
+from preparse.core.warnings import *
 
-__all__ = ["OptDict"]
+__all__ = ["Optdict"]
 
 
-class OptDict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
+class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
     __slots__ = ()
 
     data: frozendict[str, Nargs]