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

preparse/_processing/__init__.py

@@ -15,11 +15,10 @@ __all__ = ["process"]
 def process(
     args: Optional[Iterable] = None,
     *,
+    abbr: Optional[Tuning],
     allowslong: bool,
     allowsshort: bool,
     bundling: Tuning,
-    expandsabbr: bool,
-    expectsabbr: bool,
     expectsposix: bool,
     optdict: dict,
     prog: str,
@@ -32,10 +31,9 @@ def process(
     items = pull(args)
     items = parse(
         items,
+        abbr=abbr,
         allowslong=allowslong,
         allowsshort=allowsshort,
-        expandsabbr=expandsabbr,
-        expectsabbr=expectsabbr,
         expectsposix=expectsposix,
         optdict=optdict,
         prog=prog,

preparse/_processing/parsing.py

@@ -18,7 +18,10 @@ PUAW = warnings.PreparseUnallowedArgumentWarning
 PRAW = warnings.PreparseRequiredArgumentWarning
 
 
-def parse(args: list[str], **kwargs: Any) -> list[Item]:
+def parse(
+    args: list[str],
+    **kwargs: Any,
+) -> list[Item]:
     return list(parse_generator(args, **kwargs))
 
 
@@ -64,10 +67,9 @@ def parse_cause(
 def parse_generator(
     items: list[Positional],
     *,
+    abbr: Optional[Tuning],
     allowslong: bool,
     allowsshort: bool,
-    expandsabbr: bool,
-    expectsabbr: bool,
     expectsposix: bool,
     optdict: dict,
     prog: str,
@@ -103,11 +105,10 @@ def parse_generator(
             continue
         last = parse_option(
             item.value,
+            abbr=abbr,
             allowslong=allowslong,
             allowsshort=allowsshort,
             cause=cause,
-            expandsabbr=expandsabbr,
-            expectsabbr=expectsabbr,
             optdict=optdict,
         )
         if not last.ishungry():
@@ -123,24 +124,12 @@ def parse_generator(
     yield last
 
 
-def parse_islong(
-    arg: str,
-    *,
-    allowslong: bool,
-    allowsshort: bool,
-) -> bool:
-    if allowslong and allowsshort:
-        return arg.startswith("--")
-    else:
-        return not allowsshort
-
-
 def parse_long(
     arg: str,
     *,
+    abbr: Optional[Tuning],
+    allowsshort: bool,
     cause: FunctionType,
-    expandsabbr: bool,
-    expectsabbr: bool,
     optdict: dict,
 ) -> Long:
     ans: Long
@@ -153,7 +142,7 @@ def parse_long(
     ans.abbrlen = len(ans.fullkey)
     if ans.fullkey in optdict.keys():
         parts = [ans.fullkey]
-    elif expectsabbr:
+    elif abbr is not None:
         parts = parse_long_startswith(ans.abbr, keys=optdict.keys())
     else:
         parts = list()  # can be assumed
@@ -166,8 +155,17 @@ def parse_long(
         cause(PAOW, option=arg, possibilities=parts)
         return ans
     (ans.fullkey,) = parts
-    if expandsabbr:
+    if abbr == Tuning.MINIMIZE:
         ans.abbrlen = len(ans.fullkey)
+    if abbr == Tuning.MAXIMIZE:
+        parts = list(optdict.keys())
+        parts.remove(ans.fullkey)
+        ans.abbrlen = parse_minlen(
+            abbr=ans.abbr,
+            allowsshort=allowsshort,
+            joined=ans.joined,
+            keys=tuple(parts),
+        )
     ans.nargs = optdict[ans.fullkey]
     if (ans.nargs == Nargs.NO_ARGUMENT) and (ans.right is not None):
         cause(PUAW, option=ans.fullkey)
@@ -188,21 +186,37 @@ def parse_long_startswith(
     return ans
 
 
+def parse_minlen(
+    *,
+    abbr: str,
+    allowsshort: bool,
+    joined: bool,
+    keys: tuple[str, ...],
+) -> int:
+    m: int
+    n: int
+    m = 2 + allowsshort - joined
+    n = len(abbr)
+    while n >= m and not any(z.startswith(abbr[:n]) for z in keys):
+        n -= 1
+    return n + 1
+
+
 def parse_option(
     arg: str,
     *,
+    abbr: Optional[Tuning],
+    allowslong: bool,
+    allowsshort: bool,
     cause: FunctionType,
-    expandsabbr: bool,
-    expectsabbr: bool,
     optdict: dict,
-    **kwargs: Any,
 ) -> Option:
-    if parse_islong(arg, **kwargs):
+    if (allowslong and arg.startswith("--")) or not allowsshort:
         return parse_long(
             arg,
+            abbr=abbr,
+            allowsshort=allowsshort,
             cause=cause,
-            expandsabbr=expandsabbr,
-            expectsabbr=expectsabbr,
             optdict=optdict,
         )
     else:

preparse/core/PreParser.py

@@ -23,11 +23,10 @@ __all__ = ["PreParser"]
 
 class PreParser(Copyable):
 
+    abbr: Optional[Tuning]
     allowslong: bool
     allowsshort: bool
     bundling: Tuning
-    expandsabbr: bool
-    expectsabbr: bool
     expectsposix: bool
     optdict: Optdict
     prog: str
@@ -41,11 +40,10 @@ class PreParser(Copyable):
     def __init__(
         self: Self,
         *,
+        abbr: Optional[Tuning] = Tuning.MINIMIZE,
         allowslong: Any = True,
         allowsshort: Any = True,
         bundling: Any = Tuning.MAINTAIN,
-        expandsabbr: Any = True,
-        expectsabbr: Any = True,
         expectsposix: Any = False,
         optdict: Any = (),
         prog: Any = None,
@@ -53,11 +51,10 @@ class PreParser(Copyable):
         special: Any = Tuning.MAINTAIN,
         warn: Callable = str,
     ) -> None:
+        self.abbr = abbr
         self.allowslong = allowslong
         self.allowsshort = allowsshort
         self.bundling = bundling
-        self.expandsabbr = expandsabbr
-        self.expectsabbr = expectsabbr
         self.expectsposix = expectsposix
         self.optdict = optdict
         self.prog = prog
@@ -69,6 +66,11 @@ class PreParser(Copyable):
     def __repr__(self: Self) -> str:
         return datarepr(type(self).__name__, **self.todict())
 
+    @dataprop
+    def abbr(self: Self, value: Any) -> bool:
+        if value is not None:
+            return Tuning(value)
+
     @dataprop
     def allowslong(self: Self, value: Any) -> bool:
         return bool(value)
@@ -90,14 +92,6 @@ class PreParser(Copyable):
     def copy(self: Self) -> Self:
         return type(self)(**self.todict())
 
-    @dataprop
-    def expandsabbr(self: Self, value: Any) -> bool:
-        return bool(value)
-
-    @dataprop
-    def expectsabbr(self: Self, value: Any) -> bool:
-        return bool(value)
-
     @dataprop
     def expectsposix(self: Self, value: Any) -> bool:
         if value == "infer":