preparse 2.0.0.dev5__py3-none-any.whl → 2.0.0.dev7__py3-none-any.whl

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/_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/_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/_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/_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/_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/_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/_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/_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/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]

preparse/core/PreParser.py

@@ -14,26 +14,26 @@ from tofunc import tofunc
 from preparse._processing import *
 from preparse._utils.dataprop import dataprop
 from preparse.core.Click import Click
-from preparse.core.OptDict import OptDict
-from preparse.enums import *
-from preparse.warners import *
+from preparse.core.enums import *
+from preparse.core.Optdict import *
+from preparse.core.warnings import *
 
 __all__ = ["PreParser"]
 
 
 class PreParser(Copyable):
 
-    allowsLong: bool
-    allowsShort: bool
+    allowslong: bool
+    allowsshort: bool
     bundling: Tuning
     expandsabbr: bool
     expectsabbr: bool
-    expectsPOSIX: bool
-    optDict: OptDict
+    expectsposix: bool
+    optdict: Optdict
     prog: str
-    reconcilesOrders: bool
+    reconcilesorders: bool
     special: Tuning
-    warn: Callable
+    warn: types.FunctionType
 
     __slots__ = ("_data",)
 
@@ -41,27 +41,27 @@ class PreParser(Copyable):
     def __init__(
         self: Self,
         *,
-        allowsLong: Any = True,
-        allowsShort: Any = True,
+        allowslong: Any = True,
+        allowsshort: Any = True,
         bundling: Any = Tuning.MAINTAIN,
         expandsabbr: Any = True,
         expectsabbr: Any = True,
-        expectsPOSIX: Any = False,
-        optDict: Any = (),
+        expectsposix: Any = False,
+        optdict: Any = (),
         prog: Any = None,
-        reconcilesOrders: Any = True,
+        reconcilesorders: Any = True,
         special: Any = Tuning.MAINTAIN,
-        warn: types.FunctionType = str,
+        warn: Callable = str,
     ) -> None:
-        self.allowsLong = allowsLong
-        self.allowsShort = allowsShort
+        self.allowslong = allowslong
+        self.allowsshort = allowsshort
         self.bundling = bundling
         self.expandsabbr = expandsabbr
         self.expectsabbr = expectsabbr
-        self.expectsPOSIX = expectsPOSIX
-        self.optDict = optDict
+        self.expectsposix = expectsposix
+        self.optdict = optdict
         self.prog = prog
-        self.reconcilesOrders = reconcilesOrders
+        self.reconcilesorders = reconcilesorders
         self.special = special
         self.warn = warn
 
@@ -70,11 +70,11 @@ class PreParser(Copyable):
         return datarepr(type(self).__name__, **self.todict())
 
     @dataprop
-    def allowsLong(self: Self, value: Any) -> bool:
+    def allowslong(self: Self, value: Any) -> bool:
         return bool(value)
 
     @dataprop
-    def allowsShort(self: Self, value: Any) -> bool:
+    def allowsshort(self: Self, value: Any) -> bool:
         return bool(value)
 
     @dataprop
@@ -99,22 +99,22 @@ class PreParser(Copyable):
         return bool(value)
 
     @dataprop
-    def expectsPOSIX(self: Self, value: Any) -> bool:
+    def expectsposix(self: Self, value: Any) -> bool:
         if value == "infer":
             return bool(os.environ.get("POSIXLY_CORRECT"))
         else:
             return bool(value)
 
     @dataprop
-    def optDict(self: Self, value: Any) -> OptDict:
+    def optdict(self: Self, value: Any) -> Optdict:
         "This property gives a dictionary of options."
-        dataA: OptDict
-        if "optDict" not in self._data.keys():
-            self._data["optDict"] = OptDict()
-        dataA = OptDict(value)
-        self._data["optDict"].clear()
-        self._data["optDict"].update(dataA)
-        return self._data["optDict"]
+        dataA: Optdict
+        if "optdict" not in self._data.keys():
+            self._data["optdict"] = Optdict()
+        dataA = Optdict(value)
+        self._data["optdict"].clear()
+        self._data["optdict"].update(dataA)
+        return self._data["optdict"]
 
     def parse_args(
         self: Self,
@@ -132,16 +132,16 @@ class PreParser(Copyable):
             return str(value)
 
     @dataprop
-    def reconcilesOrders(self: Self, value: Any) -> bool:
+    def reconcilesorders(self: Self, value: Any) -> bool:
         return bool(value)
 
     def reflectClickCommand(self: Self, cmd: cl.Command) -> None:
         "This method causes the current instance to reflect a click.Command object."
-        optDict: dict[str, Nargs]
+        optdict: dict[str, Nargs]
         nargs: Nargs
         opt: Any
         param: Any
-        optDict = dict()
+        optdict = dict()
         for param in cmd.params:
             if not isinstance(param, cl.Option):
                 continue
@@ -152,9 +152,9 @@ class PreParser(Copyable):
             else:
                 nargs = Nargs.OPTIONAL_ARGUMENT
             for opt in param.opts:
-                optDict[str(opt)] = nargs
-        self.optDict.clear()
-        self.optDict.update(optDict)
+                optdict[str(opt)] = nargs
+        self.optdict.clear()
+        self.optdict.update(optdict)
 
     def reflectClickContext(self: Self, ctx: cl.Context) -> None:
         "This method causes the current instance to reflect a click.Context object."

preparse/core/__init__.py

@@ -1,4 +1,5 @@
 from preparse.core.Click import *
-from preparse.core.OptDict import *
+from preparse.core.enums import *
+from preparse.core.Optdict import *
 from preparse.core.PreParser import *
-from preparse.enums import *
+from preparse.core.warnings import *