preparse 1.0.13.post0__tar.gz → 1.0.13.post1.dev1__tar.gz

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 1.0.13.post0
+Version: 1.0.13.post1.dev1
 Summary: This project preparses args for further parsing later on.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/docs/v1.0.rst

@@ -56,8 +56,8 @@ 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[..., Any] = str)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This class is the centerpiece of the preparse. Its behaviour follows the principles of getopt from C.
 
@@ -111,8 +111,8 @@ Options not found within the dictionary
 cause a ``preparse.PreparseInvalidOptionWarning``
 and are then assumed to have no arguments.
 
-``parse_args(args: Optional[Iterable] = None) -> list[str]``
-""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+``parse_args(args: Iterable[Any] | None = None) -> list[str]``
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
 This method is at the core of the class.
 It returns a preparsed list of arguments.
@@ -148,8 +148,8 @@ Concretely the prog property is changed.
 
 This ``preparse.Tuning`` property determines the approach to the special argument ``'--'``.
 
-``todict() -> dict``
-""""""""""""""""""""
+``todict() -> dict[str, Any]``
+""""""""""""""""""""""""""""""
 
 This method a dict representing the current instance.
 

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/pyproject.toml

@@ -37,7 +37,7 @@ license-files = [
 name = "preparse"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.0.13.post0"
+version = "1.0.13.post1.dev1"
 
 [project.urls]
 Download = "https://pypi.org/project/preparse/#files"

preparse-1.0.13.post1.dev1/src/preparse/__init__.py

@@ -0,0 +1,33 @@
+__all__: list[str] = [
+    "Click",
+    "Nargs",
+    "Optdict",
+    "PreParser",
+    "PreparseAmbiguousOptionWarning",
+    "PreparseInvalidOptionWarning",
+    "PreparseRequiredArgumentWarning",
+    "PreparseUnallowedArgumentWarning",
+    "PreparseWarning",
+    "Tuning",
+    "core",
+    "enums",
+    "test",
+    "tests",
+    "warnings",
+]
+
+from preparse.core import (
+    Click,
+    Nargs,
+    Optdict,
+    PreparseAmbiguousOptionWarning,
+    PreparseInvalidOptionWarning,
+    PreParser,
+    PreparseRequiredArgumentWarning,
+    PreparseUnallowedArgumentWarning,
+    PreparseWarning,
+    Tuning,
+    enums,
+    warnings,
+)
+from preparse.tests import test

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_items/Bundle.py

@@ -1,13 +1,12 @@
-from typing import *
+__all__: list[str] = ["Bundle"]
+
+from typing import Any, Self
 
 import setdoc
 
 from preparse._items.Item import Item
 from preparse._items.Option import Option
-from preparse._utils.dataprop import dataprop
-from preparse.core.enums import *
-
-__all__ = ["Bundle"]
+from preparse.core.enums import Nargs, Tuning
 
 
 class Bundle(Option):
@@ -15,7 +14,7 @@ class Bundle(Option):
     chars: str
     joined: bool
     nargs: Nargs
-    right: Optional[str]
+    right: str | None
 
     __slots__ = ()
 
@@ -25,14 +24,14 @@ class Bundle(Option):
         *,
         chars: str,
         joined: bool = False,
-        right: Optional[str] = None,
+        right: str | None = None,
     ) -> None:
         self.chars = chars
         self.joined = joined
         self.right = right
 
     @classmethod
-    def _split_allowslong(cls: type, chars: str) -> list[str]:
+    def _split_allowslong(cls: type[Self], chars: str) -> list[str]:
         ans: list[str]
         x: str
         ans = list()
@@ -44,7 +43,7 @@ class Bundle(Option):
         return ans
 
     @classmethod
-    def _split_shortonly(cls: type, chars: str) -> list[str]:
+    def _split_shortonly(cls: type[Self], chars: str) -> list[str]:
         ans: list[str]
         x: str
         ans = list()
@@ -61,9 +60,14 @@ class Bundle(Option):
                 x = x[:-1]
         return ans
 
-    @dataprop
-    def chars(self: Self, x: Any) -> str:
-        return str(x)
+    @property
+    def chars(self: Self) -> str:
+        return self._data["chars"]
+
+    @chars.setter
+    def chars(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["chars"] = str(x)
 
     def deparse(self: Self) -> list[str]:
         if self.right is None:

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_items/Item.py

@@ -1,12 +1,12 @@
+__all__: list[str] = ["Item"]
+
 import abc
-from typing import *
+from typing import Any, Self
 
 import setdoc
 from copyable import Copyable
 
-from preparse.core.enums import *
-
-__all__ = ["Item"]
+from preparse.core.enums import Nargs, Tuning
 
 
 class Item(Copyable):
@@ -21,11 +21,11 @@ class Item(Copyable):
 
     @classmethod
     @abc.abstractmethod
-    def sortkey(cls: type) -> int: ...
+    def sortkey(cls: type[Self]) -> int: ...
 
-    def todict(self: Self) -> dict:
+    def todict(self: Self) -> dict[str, Any]:
         "This method returns a dict representing the current instance."
-        ans: dict
+        ans: dict[str, Any]
         try:
             ans = self._data
         except AttributeError:

preparse-1.0.13.post1.dev1/src/preparse/_items/Long.py

@@ -0,0 +1,68 @@
+__all__: list[str] = ["Long"]
+
+import operator
+from typing import Any, Self, SupportsIndex
+
+import setdoc
+
+from preparse._items.Option import Option
+from preparse.core.enums import Nargs, Tuning
+
+
+class Long(Option):
+
+    abbr: str
+    abbrlen: int | None
+    fullkey: str
+    joined: bool
+    nargs: Nargs
+    right: str | None
+
+    __slots__ = ()
+
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        *,
+        abbrlen: int | None = None,
+        fullkey: str,
+        joined: bool | str = False,
+        right: str | None = None,
+    ) -> None:
+        self.fullkey = fullkey
+        self.abbrlen = abbrlen
+        self.joined = joined
+        self.right = right
+
+    @property
+    def abbr(self: Self) -> str:
+        return self.fullkey[: self.abbrlen]
+
+    @property
+    def abbrlen(self: Self) -> int | None:
+        return self._data["abbrlen"]
+
+    @abbrlen.setter
+    def abbrlen(self: Self, x: SupportsIndex | None) -> None:
+        self._data = getattr(self, "_data", dict())
+        if x is not None:
+            self._data["abbrlen"] = operator.index(x)
+        else:
+            self._data["abbrlen"] = None
+
+    def deparse(self: Self) -> list[str]:
+        if self.right is None:
+            return [self.abbr]
+        elif self.joined:
+            return [self.abbr + "=" + self.right]
+        else:
+            return [self.abbr, self.right]
+
+    @property
+    def fullkey(self: Self) -> str:
+        return self._data["fullkey"]
+
+    @fullkey.setter
+    def fullkey(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["fullkey"] = str(x)

preparse-1.0.13.post1.dev1/src/preparse/_items/Option.py

@@ -0,0 +1,53 @@
+__all__: list[str] = ["Option"]
+
+import operator
+from typing import Any, Self, SupportsIndex
+
+from preparse._items.Item import Item
+from preparse.core.enums import Nargs, Tuning
+
+
+class Option(Item):
+
+    joined: bool
+    nargs: Nargs
+    right: str | None
+
+    __slots__ = ()
+
+    def ishungry(self: Self) -> bool:
+        return (self.right is None) and (self.nargs == Nargs.REQUIRED_ARGUMENT)
+
+    @property
+    def joined(self: Self) -> bool:
+        return self._data["joined"]
+
+    @joined.setter
+    def joined(self: Self, x: SupportsIndex) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["joined"] = bool(operator.index(x))
+
+    @property
+    def nargs(self: Self) -> Nargs:
+        return self._data["nargs"]
+
+    @nargs.setter
+    def nargs(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["nargs"] = Nargs(x)
+
+    @property
+    def right(self: Self) -> str | None:
+        return self._data["right"]
+
+    @right.setter
+    def right(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        if x is not None:
+            self._data["right"] = str(x)
+        else:
+            self._data["right"] = None
+
+    @classmethod
+    def sortkey(cls: type[Self]) -> int:
+        return 0

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_items/Positional.py

@@ -1,12 +1,11 @@
-from typing import *
+__all__: list[str] = ["Positional"]
+
+from typing import Any, Self
 
 import setdoc
 
 from preparse._items.Item import Item
-from preparse._utils.dataprop import dataprop
-from preparse.core.enums import *
-
-__all__ = ["Positional"]
+from preparse.core.enums import Nargs, Tuning
 
 
 class Positional(Item):
@@ -26,9 +25,14 @@ class Positional(Item):
         return self.value == "-" or not self.value.startswith("-")
 
     @classmethod
-    def sortkey(cls: type) -> int:
+    def sortkey(cls: type[Self]) -> int:
         return 2
 
-    @dataprop
-    def value(self: Self, x: Any) -> str:
-        return str(x)
+    @property
+    def value(self: Self) -> str:
+        return self._data["value"]
+
+    @value.setter
+    def value(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["value"] = str(x)

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_items/Special.py

@@ -1,9 +1,9 @@
-from typing import *
+__all__: list[str] = ["Special"]
 
-from preparse._items.Item import Item
-from preparse.core.enums import *
+from typing import Self
 
-__all__ = ["Special"]
+from preparse._items.Item import Item
+from preparse.core.enums import Nargs, Tuning
 
 
 class Special(Item):
@@ -14,5 +14,5 @@ class Special(Item):
         return ["--"]
 
     @classmethod
-    def sortkey(cls: type) -> int:
+    def sortkey(cls: type[Self]) -> int:
         return 1

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_items/__init__.py

@@ -1,3 +1,12 @@
+__all__: list[str] = [
+    "Bundle",
+    "Item",
+    "Long",
+    "Option",
+    "Positional",
+    "Special",
+]
+
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
 from preparse._items.Long import Long

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_processing/__init__.py

@@ -1,19 +1,19 @@
-from types import FunctionType
-from typing import *
+__all__: list[str] = ["process"]
 
-from preparse._items import *
-from preparse._processing.deparsing import *
-from preparse._processing.digesting import *
-from preparse._processing.parsing import *
-from preparse._processing.pulling import *
-from preparse._utils import *
-from preparse.core.enums import *
+from collections.abc import Iterable
+from types import FunctionType
+from typing import Any
 
-__all__ = ["process"]
+from preparse._items import Bundle, Item, Long, Option, Positional, Special
+from preparse._processing.deparsing import deparse
+from preparse._processing.digesting import digest
+from preparse._processing.parsing import parse
+from preparse._processing.pulling import pull
+from preparse.core.enums import Nargs, Tuning
 
 
 def process(
-    args: Optional[Iterable] = None,
+    args: Iterable[Any] | None = None,
     *,
     allowslong: bool,
     allowsshort: bool,
@@ -21,7 +21,7 @@ def process(
     expandsabbr: bool,
     expectsabbr: bool,
     expectsposix: bool,
-    optdict: dict,
+    optdict: dict[str, Nargs],
     prog: str,
     reconcilesorders: bool,
     special: Tuning,

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_processing/deparsing.py

@@ -1,9 +1,7 @@
-from typing import *
+__all__: list[str] = ["deparse"]
 
 from preparse._items.Item import Item
 
-__all__ = ["deparse"]
-
 
 def deparse(items: list[Item]) -> list[str]:
     ans: list[str]

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_processing/digesting.py

@@ -1,4 +1,6 @@
-from typing import *
+__all__: list[str] = ["digest"]
+
+from typing import Any
 
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
@@ -6,10 +8,14 @@ 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.core.enums import *
-from preparse.core.warnings import *
-
-__all__ = ["digest"]
+from preparse.core.enums import Nargs, Tuning
+from preparse.core.warnings import (
+    PreparseAmbiguousOptionWarning,
+    PreparseInvalidOptionWarning,
+    PreparseRequiredArgumentWarning,
+    PreparseUnallowedArgumentWarning,
+    PreparseWarning,
+)
 
 
 def digest(

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_processing/parsing.py

@@ -1,5 +1,8 @@
+__all__: list[str] = ["parse"]
+
+from collections.abc import Generator, Iterable
 from types import FunctionType
-from typing import *
+from typing import Any
 
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
@@ -8,9 +11,12 @@ from preparse._items.Option import Option
 from preparse._items.Positional import Positional
 from preparse._items.Special import Special
 from preparse.core import warnings
-from preparse.core.enums import *
+from preparse.core.enums import Nargs, Tuning
 
-__all__ = ["parse"]
+PAOW: type[Any]
+PIOW: type[Any]
+PRAW: type[Any]
+PUAW: type[Any]
 
 PAOW = warnings.PreparseAmbiguousOptionWarning
 PIOW = warnings.PreparseInvalidOptionWarning
@@ -26,7 +32,7 @@ def parse_bundling(
     arg: str,
     *,
     cause: FunctionType,
-    optdict: dict,
+    optdict: dict[str, Nargs],
 ) -> Bundle:
     ans: Bundle
     x: int
@@ -55,7 +61,7 @@ def parse_cause(
     prog: str,
     warn: FunctionType,
 ) -> FunctionType:
-    def ans(cls: type, **kwargs: Any) -> None:
+    def ans(cls: type[Any], **kwargs: Any) -> None:
         warn(cls(prog=prog, **kwargs))
 
     return ans
@@ -68,14 +74,14 @@ def parse_generator(
     allowsshort: bool,
     expectsabbr: bool,
     expectsposix: bool,
-    optdict: dict,
+    optdict: dict[str, Nargs],
     prog: str,
     warn: FunctionType,
 ) -> Generator[Any, Any, Any]:
     broken: bool
     cause: FunctionType
-    last: Optional[Option]
     item: Positional
+    last: Option | None
     broken = not (allowslong or allowsshort)
     cause = parse_cause(prog=prog, warn=warn)
     last = None
@@ -138,7 +144,7 @@ def parse_long(
     *,
     cause: FunctionType,
     expectsabbr: bool,
-    optdict: dict,
+    optdict: dict[str, Nargs],
 ) -> Long:
     ans: Long
     parts: list[str]
@@ -188,7 +194,7 @@ def parse_option(
     *,
     cause: FunctionType,
     expectsabbr: bool,
-    optdict: dict,
+    optdict: dict[str, Nargs],
     **kwargs: Any,
 ) -> Option:
     if parse_islong(arg, **kwargs):

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/_processing/pulling.py

@@ -1,14 +1,15 @@
+__all__: list[str] = ["pull"]
+
 import sys
-from typing import *
+from collections.abc import Iterable
+from typing import Any
 
 from preparse._items.Positional import Positional
 
-__all__ = ["pull"]
-
 
-def pull(args: Optional[Iterable] = None) -> list[Positional]:
+def pull(args: Iterable[Any] | None = None) -> list[Positional]:
     "This method acquires args."
-    argiter: Iterable
+    argiter: Iterable[Any]
     if args is None:
         argiter = sys.argv[1:]
     else:

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/core/Click.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+__all__: list[str] = ["Click"]
+
 import dataclasses
 import functools
 import types
-from typing import *
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Self
 
 import overloadable
 import setdoc
@@ -12,8 +15,6 @@ from copyable import Copyable
 if TYPE_CHECKING:
     from .PreParser import PreParser
 
-__all__ = ["Click"]
-
 
 @dataclasses.dataclass
 class Click(Copyable):
@@ -47,7 +48,7 @@ class Click(Copyable):
 
     @__call__.overload("method")
     def __call__(self: Self, target: types.MethodType) -> types.MethodType:
-        func: Callable
+        func: Callable[..., Any]
         func = self(target.__func__)
         return types.MethodType(func, target.__self__)
 

{preparse-1.0.13.post0 → preparse-1.0.13.post1.dev1}/src/preparse/core/Optdict.py

@@ -1,4 +1,7 @@
-from typing import *
+__all__: list[str] = ["Optdict"]
+
+from collections.abc import Iterator
+from typing import Any, Self
 
 import cmp3
 import datahold
@@ -6,10 +9,14 @@ import setdoc
 from datarepr import datarepr
 from frozendict import frozendict
 
-from preparse.core.enums import *
-from preparse.core.warnings import *
-
-__all__ = ["Optdict"]
+from preparse.core.enums import Nargs, Tuning
+from preparse.core.warnings import (
+    PreparseAmbiguousOptionWarning,
+    PreparseInvalidOptionWarning,
+    PreparseRequiredArgumentWarning,
+    PreparseUnallowedArgumentWarning,
+    PreparseWarning,
+)
 
 
 class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
@@ -18,7 +25,7 @@ class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
     data: frozendict[str, Nargs]
 
     @setdoc.basic
-    def __cmp__(self: Self, other: Any, /) -> Optional[int]:
+    def __cmp__(self: Self, other: Any, /) -> int | None:
         if type(self) is type(other):
             return cmp3.cmp(self._data, other._data, mode="eq_strict")
         else:
@@ -38,9 +45,9 @@ class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
 
     @data.setter
     def data(self: Self, value: Any) -> None:
-        a: frozendict
-        x: map
-        y: map
+        a: frozendict[str, Nargs]
+        x: Iterator[str]
+        y: Iterator[Nargs]
         a = frozendict(value)
         x = map(str, a.keys())
         y = map(Nargs, a.values())