preparse 1.0.13.post1.dev0__tar.gz → 1.0.13.post2__tar.gz

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/PKG-INFO

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

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/pyproject.toml

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

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_items/Bundle.py

@@ -1,21 +1,20 @@
+from __future__ import annotations
+
 __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 Nargs, Tuning
 
 
 class Bundle(Option):
 
-    chars: str
-    joined: bool
-    nargs: Nargs
-    right: str | None
+    # chars: str
+    # joined: bool
+    # nargs: Nargs
+    # right: str | None
 
     __slots__ = ()
 
@@ -38,7 +37,7 @@ class Bundle(Option):
         ans = list()
         for x in chars:
             if x == "-":
-                ans[-1].chars += "-"
+                ans[-1] += "-"
             else:
                 ans.append(x)
         return ans
@@ -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"]  # type: ignore[no-any-return]
+
+    @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:
@@ -73,8 +77,8 @@ class Bundle(Option):
         else:
             return ["-" + self.chars, self.right]
 
-    def split(self: Self, *, allowslong: bool) -> list[Item]:
-        ans: list[Self]
+    def split(self: Self, *, allowslong: bool) -> list[Bundle]:
+        ans: list[Bundle]
         parts: list[str]
         x: str
         if allowslong:

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_items/Item.py

@@ -6,12 +6,12 @@ from typing import Any, Self
 import setdoc
 from copyable import Copyable
 
-from preparse.core.enums import Nargs, Tuning
-
 
 class Item(Copyable):
     __slots__ = ("_data",)
 
+    _data: dict[str, Any]
+
     @setdoc.basic
     def copy(self: Self) -> Self:
         return type(self)(**self.todict())

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_items/Long.py

@@ -6,18 +6,16 @@ from typing import Any, Self, SupportsIndex
 import setdoc
 
 from preparse._items.Option import Option
-from preparse._utils.dataprop import dataprop
-from preparse.core.enums import Nargs, Tuning
 
 
 class Long(Option):
 
-    abbr: str
-    abbrlen: int | None
-    fullkey: str
-    joined: bool
-    nargs: Nargs
-    right: str | None
+    # abbr: str
+    # abbrlen: int | None
+    # fullkey: str
+    # joined: bool
+    # nargs: Nargs
+    # right: str | None
 
     __slots__ = ()
 
@@ -27,7 +25,7 @@ class Long(Option):
         *,
         abbrlen: int | None = None,
         fullkey: str,
-        joined: bool | str = False,
+        joined: bool = False,
         right: str | None = None,
     ) -> None:
         self.fullkey = fullkey
@@ -39,10 +37,17 @@ class Long(Option):
     def abbr(self: Self) -> str:
         return self.fullkey[: self.abbrlen]
 
-    @dataprop
-    def abbrlen(self: Self, x: SupportsIndex | None) -> int | None:
+    @property
+    def abbrlen(self: Self) -> int | None:
+        return self._data["abbrlen"]  # type: ignore[no-any-return]
+
+    @abbrlen.setter
+    def abbrlen(self: Self, x: SupportsIndex | None) -> None:
+        self._data = getattr(self, "_data", dict())
         if x is not None:
-            return operator.index(x)
+            self._data["abbrlen"] = operator.index(x)
+        else:
+            self._data["abbrlen"] = None
 
     def deparse(self: Self) -> list[str]:
         if self.right is None:
@@ -52,6 +57,11 @@ class Long(Option):
         else:
             return [self.abbr, self.right]
 
-    @dataprop
-    def fullkey(self: Self, x: Any) -> str:
-        return str(x)
+    @property
+    def fullkey(self: Self) -> str:
+        return self._data["fullkey"]  # type: ignore[no-any-return]
+
+    @fullkey.setter
+    def fullkey(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["fullkey"] = str(x)

preparse-1.0.13.post2/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
+
+
+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"]  # type: ignore[no-any-return]
+
+    @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"]  # type: ignore[no-any-return]
+
+    @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"]  # type: ignore[no-any-return]
+
+    @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.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_items/Positional.py

@@ -5,13 +5,11 @@ from typing import Any, Self
 import setdoc
 
 from preparse._items.Item import Item
-from preparse._utils.dataprop import dataprop
-from preparse.core.enums import Nargs, Tuning
 
 
 class Positional(Item):
 
-    value: str
+    # value: str
 
     __slots__ = ()
 
@@ -29,6 +27,11 @@ class Positional(Item):
     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"]  # type: ignore[no-any-return]
+
+    @value.setter
+    def value(self: Self, x: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["value"] = str(x)

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_items/Special.py

@@ -3,7 +3,6 @@ __all__: list[str] = ["Special"]
 from typing import Self
 
 from preparse._items.Item import Item
-from preparse.core.enums import Nargs, Tuning
 
 
 class Special(Item):

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_processing/__init__.py

@@ -4,12 +4,11 @@ from collections.abc import Iterable
 from types import FunctionType
 from typing import Any
 
-from preparse._items import Bundle, Item, Long, Option, Positional, Special
+from preparse._items import Item, Positional
 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._utils import dataprop
 from preparse.core.enums import Nargs, Tuning
 
 
@@ -30,9 +29,10 @@ def process(
 ) -> list[str]:
     "This method parses args."
     items: list[Item]
-    items = pull(args)
+    positionals: list[Positional]
+    positionals = pull(args)
     items = parse(
-        items,
+        positionals,
         allowslong=allowslong,
         allowsshort=allowsshort,
         expectsabbr=expectsabbr,

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_processing/digesting.py

@@ -8,14 +8,7 @@ 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 Nargs, Tuning
-from preparse.core.warnings import (
-    PreparseAmbiguousOptionWarning,
-    PreparseInvalidOptionWarning,
-    PreparseRequiredArgumentWarning,
-    PreparseUnallowedArgumentWarning,
-    PreparseWarning,
-)
+from preparse.core.enums import Tuning
 
 
 def digest(
@@ -146,7 +139,7 @@ def digest_order(
         if isinstance(ans[index], Special):
             comp = True
             break
-        if not ans[index].isobvious():
+        if not ans[index].isobvious():  # type: ignore[attr-defined]
             comp = False
     if not comp:
         ans.insert(index + 1, Special())
@@ -183,9 +176,9 @@ def digest_special_max(items: list[Item]) -> list[Item]:
             break
         if isinstance(ans[index], Positional):
             continue
-        if ans[index].ishungry():
-            ans[index].joined = False
-            ans[index].right = "--"
+        if ans[index].ishungry():  # type: ignore[attr-defined]
+            ans[index].joined = False  # type: ignore[attr-defined]
+            ans[index].right = "--"  # type: ignore[attr-defined]
         ans.insert(index + 1, Special())
         break
     return ans
@@ -215,7 +208,7 @@ def digest_special_min(
             break
         if isinstance(ans[index], Special):
             break
-        isdel = ans[index].isobvious()
+        isdel = ans[index].isobvious()  # type: ignore[attr-defined]
         if not (isdel or isposix):
             break
     if isdel:

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/_processing/parsing.py

@@ -10,21 +10,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 import warnings
-from preparse.core.enums import Nargs, Tuning
+from preparse.core.enums import Nargs
+from preparse.core.warnings import PreparseAmbiguousOptionWarning as PAOW
+from preparse.core.warnings import PreparseInvalidOptionWarning as PIOW
+from preparse.core.warnings import PreparseRequiredArgumentWarning as PRAW
+from preparse.core.warnings import PreparseUnallowedArgumentWarning as PUAW
 
-PAOW: type[Any]
-PIOW: type[Any]
-PRAW: type[Any]
-PUAW: type[Any]
 
-PAOW = warnings.PreparseAmbiguousOptionWarning
-PIOW = warnings.PreparseInvalidOptionWarning
-PUAW = warnings.PreparseUnallowedArgumentWarning
-PRAW = warnings.PreparseRequiredArgumentWarning
-
-
-def parse(args: list[str], **kwargs: Any) -> list[Item]:
+def parse(args: list[Positional], **kwargs: Any) -> list[Item]:
     return list(parse_generator(args, **kwargs))
 
 
@@ -64,7 +57,7 @@ def parse_cause(
     def ans(cls: type[Any], **kwargs: Any) -> None:
         warn(cls(prog=prog, **kwargs))
 
-    return ans
+    return ans  # type: ignore[return-value]
 
 
 def parse_generator(
@@ -77,11 +70,11 @@ def parse_generator(
     optdict: dict[str, Nargs],
     prog: str,
     warn: FunctionType,
-) -> Generator[Any, Any, Any]:
+) -> Generator[Item, None, None]:
     broken: bool
     cause: FunctionType
     item: Positional
-    last: Option | None
+    last: Long | Bundle | None
     broken = not (allowslong or allowsshort)
     cause = parse_cause(prog=prog, warn=warn)
     last = None
@@ -196,7 +189,7 @@ def parse_option(
     expectsabbr: bool,
     optdict: dict[str, Nargs],
     **kwargs: Any,
-) -> Option:
+) -> Bundle | Long:
     if parse_islong(arg, **kwargs):
         return parse_long(
             arg,

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/core/Click.py

@@ -32,7 +32,7 @@ class Click(Copyable):
             return "method"
         return "other"
 
-    @__call__.overload("function")
+    @__call__.overload("function")  # type: ignore[no-redef]
     def __call__(self: Self, target: types.FunctionType) -> types.FunctionType:
         @functools.wraps(target)
         def ans(cmd: Any, ctx: Any, args: Any) -> Any:
@@ -46,13 +46,13 @@ class Click(Copyable):
 
         return ans
 
-    @__call__.overload("method")
+    @__call__.overload("method")  # type: ignore[no-redef]
     def __call__(self: Self, target: types.MethodType) -> types.MethodType:
         func: Callable[..., Any]
         func = self(target.__func__)
         return types.MethodType(func, target.__self__)
 
-    @__call__.overload("other")
+    @__call__.overload("other")  # type: ignore[no-redef]
     def __call__(self: Self, target: Any) -> Any:
         target.parse_args = self(target.parse_args)
         return target

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/core/Optdict.py

@@ -1,47 +1,53 @@
 __all__: list[str] = ["Optdict"]
 
-from collections.abc import Iterator
-from typing import Any, Self
+from collections.abc import Iterable, Iterator
+from typing import Any, Self, overload
 
 import cmp3
 import datahold
+import datahold.typing
 import setdoc
 from datarepr import datarepr
 from frozendict import frozendict
 
-from preparse.core.enums import Nargs, Tuning
-from preparse.core.warnings import (
-    PreparseAmbiguousOptionWarning,
-    PreparseInvalidOptionWarning,
-    PreparseRequiredArgumentWarning,
-    PreparseUnallowedArgumentWarning,
-    PreparseWarning,
-)
+from preparse.core.enums import Nargs
 
 
 class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
     __slots__ = ()
 
-    data: frozendict[str, Nargs]
-
     @setdoc.basic
     def __cmp__(self: Self, other: Any, /) -> int | None:
         if type(self) is type(other):
-            return cmp3.cmp(self._data, other._data, mode="eq_strict")
+            return cmp3.cmp(self._data, other._data, mode="eq_strict")  # type: ignore[no-any-return]
         else:
-            return cmp3.cmp(self._data, other, mode="eq_strict")
+            return cmp3.cmp(self._data, other, mode="eq_strict")  # type: ignore[no-any-return]
 
     __format__ = object.__format__
 
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        other: (
+            datahold.typing.SupportsKeysAndGetitem.SupportsKeysAndGetitem[
+                object, object
+            ]
+            | Iterable[tuple[object, object]]
+        ) = (),
+        /,
+        **kwargs: object,
+    ) -> None:
+        datahold.HoldDict.__init__(self, other, **kwargs)
+
     @setdoc.basic
     def __repr__(self: Self, /) -> str:
         return datarepr(type(self).__name__, dict(self._data))
 
     __str__ = object.__str__
 
-    @property
+    @property  # type: ignore[override]
     def data(self: Self) -> frozendict[str, Nargs]:
-        return frozendict[str, Nargs](self._data)
+        return frozendict[str, Nargs](self._data)  # type: ignore[arg-type]
 
     @data.setter
     def data(self: Self, value: Any) -> None:

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/core/PreParser.py

@@ -15,33 +15,13 @@ from datarepr import datarepr
 from tofunc import tofunc
 
 from preparse._processing import process
-from preparse._utils.dataprop import dataprop
 from preparse.core.Click import Click
 from preparse.core.enums import Nargs, Tuning
 from preparse.core.Optdict import Optdict
-from preparse.core.warnings import (
-    PreparseAmbiguousOptionWarning,
-    PreparseInvalidOptionWarning,
-    PreparseRequiredArgumentWarning,
-    PreparseUnallowedArgumentWarning,
-    PreparseWarning,
-)
 
 
 class PreParser(Copyable):
 
-    allowslong: bool
-    allowsshort: bool
-    bundling: Tuning
-    expandsabbr: bool
-    expectsabbr: bool
-    expectsposix: bool
-    optdict: Optdict
-    prog: str
-    reconcilesorders: bool
-    special: Tuning
-    warn: types.FunctionType
-
     __slots__ = ("_data",)
 
     @setdoc.basic
@@ -76,18 +56,33 @@ class PreParser(Copyable):
     def __repr__(self: Self) -> str:
         return datarepr(type(self).__name__, **self.todict())
 
-    @dataprop
-    def allowslong(self: Self, value: Any) -> bool:
-        return bool(value)
+    @property
+    def allowslong(self: Self) -> bool:
+        return self._data["allowslong"]
+
+    @allowslong.setter
+    def allowslong(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["allowslong"] = bool(value)
+
+    @property
+    def allowsshort(self: Self) -> bool:
+        return self._data["allowsshort"]  # type: ignore[no-any-return]
 
-    @dataprop
-    def allowsshort(self: Self, value: Any) -> bool:
-        return bool(value)
+    @allowsshort.setter
+    def allowsshort(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["allowsshort"] = bool(value)
 
-    @dataprop
-    def bundling(self: Self, value: Any) -> Tuning:
+    @property
+    def bundling(self: Self) -> Tuning:
         "This property decides how to approach the bundling of short options."
-        return Tuning(value)
+        return self._data["bundling"]  # type: ignore[no-any-return]
+
+    @bundling.setter
+    def bundling(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["bundling"] = Tuning(value)
 
     def click(self: Self, cmd: Any = True, ctx: Any = True) -> Click:
         "This method returns a decorator that infuses the current instance into parse_args."
@@ -97,31 +92,53 @@ class PreParser(Copyable):
     def copy(self: Self) -> Self:
         return type(self)(**self.todict())
 
-    @dataprop
-    def expandsabbr(self: Self, value: Any) -> bool:
-        return bool(value)
+    @property
+    def expandsabbr(self: Self) -> bool:
+        return self._data["expandsabbr"]  # type: ignore[no-any-return]
+
+    @expandsabbr.setter
+    def expandsabbr(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["expandsabbr"] = bool(value)
+
+    @property
+    def expectsabbr(self: Self) -> bool:
+        return self._data["expectsabbr"]  # type: ignore[no-any-return]
 
-    @dataprop
-    def expectsabbr(self: Self, value: Any) -> bool:
-        return bool(value)
+    @expectsabbr.setter
+    def expectsabbr(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["expectsabbr"] = bool(value)
 
-    @dataprop
-    def expectsposix(self: Self, value: Any) -> bool:
+    @property
+    def expectsposix(self: Self) -> bool:
+        return self._data["expectsposix"]  # type: ignore[no-any-return]
+
+    @expectsposix.setter
+    def expectsposix(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
         if value == "infer":
-            return bool(os.environ.get("POSIXLY_CORRECT"))
+            self._data["expectsposix"] = bool(
+                os.environ.get("POSIXLY_CORRECT")
+            )
         else:
-            return bool(value)
+            self._data["expectsposix"] = bool(value)
 
-    @dataprop
-    def optdict(self: Self, value: Any) -> Optdict:
+    @property
+    def optdict(self: Self) -> Optdict:
         "This property gives a dictionary of options."
+        return self._data["optdict"]  # type: ignore[no-any-return]
+
+    @optdict.setter
+    def optdict(self: Self, value: Any) -> None:
         dataA: Optdict
+        self._data = getattr(self, "_data", dict())
         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"]
+        self._data["optdict"] = self._data["optdict"]
 
     def parse_args(
         self: Self,
@@ -130,17 +147,27 @@ class PreParser(Copyable):
         "This method parses args."
         return process(args, **self.todict())
 
-    @dataprop
-    def prog(self: Self, value: Any) -> str:
+    @property
+    def prog(self: Self) -> str:
         "This property represents the name of the program."
+        return self._data["prog"]  # type: ignore[no-any-return]
+
+    @prog.setter
+    def prog(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
         if value is None:
-            return str(os.path.basename(sys.argv[0]))
+            self._data["prog"] = str(os.path.basename(sys.argv[0]))
         else:
-            return str(value)
+            self._data["prog"] = str(value)
 
-    @dataprop
-    def reconcilesorders(self: Self, value: Any) -> bool:
-        return bool(value)
+    @property
+    def reconcilesorders(self: Self) -> bool:
+        return self._data["reconcilesorders"]  # type: ignore[no-any-return]
+
+    @reconcilesorders.setter
+    def reconcilesorders(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["reconcilesorders"] = bool(value)
 
     def reflectClickCommand(self: Self, cmd: cl.Command) -> None:
         "This method causes the current instance to reflect a click.Command object."
@@ -167,10 +194,15 @@ class PreParser(Copyable):
         "This method causes the current instance to reflect a click.Context object."
         self.prog = ctx.info_name
 
-    @dataprop
-    def special(self: Self, value: Any) -> Tuning:
+    @property
+    def special(self: Self) -> Tuning:
         "This Tuning property determines the approach towards the special argument."
-        return Tuning(value)
+        return self._data["special"]  # type: ignore[no-any-return]
+
+    @special.setter
+    def special(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["special"] = Tuning(value)
 
     def todict(self: Self) -> dict[str, Any]:
         "This method returns a dict representing the current instance."
@@ -183,7 +215,12 @@ class PreParser(Copyable):
         else:
             return dict(ans)
 
-    @dataprop
-    def warn(self: Self, value: Callable[..., Any]) -> types.FunctionType:
+    @property
+    def warn(self: Self) -> types.FunctionType:
         "This property gives a function that takes in the warnings."
-        return tofunc(value)
+        return self._data["warn"]  # type: ignore[no-any-return]
+
+    @warn.setter
+    def warn(self: Self, value: Callable[..., Any]) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["warn"] = tofunc(value)

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/core/warnings.py

@@ -14,13 +14,8 @@ import setdoc
 from copyable import Copyable
 from datarepr import datarepr
 
-from preparse._utils import dataprop
-
 
 class PreparseWarning(Warning, Copyable):
-    args: tuple[str]
-    option: str
-    prog: str
 
     @setdoc.basic
     def __repr__(self: Self) -> str:
@@ -31,7 +26,7 @@ class PreparseWarning(Warning, Copyable):
         return f"{self.prog}: {self.getmsg()}"
 
     @property
-    def args(self: Self) -> tuple[str]:
+    def args(self: Self) -> tuple[str]:  # type: ignore[override]
         "This property returns (str(self),)."
         return (str(self),)
 
@@ -42,13 +37,23 @@ class PreparseWarning(Warning, Copyable):
     @abstractmethod
     def getmsg(self: Self) -> str: ...
 
-    @dataprop
-    def option(self: Self, value: Any) -> str:
-        return str(value)
+    @property
+    def option(self: Self) -> str:
+        return self._data["option"]
+
+    @option.setter
+    def option(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["option"] = str(value)
+
+    @property
+    def prog(self: Self) -> str:
+        return self._data["prog"]  # type: ignore[no-any-return]
 
-    @dataprop
-    def prog(self: Self, value: Any) -> str:
-        return str(value)
+    @prog.setter
+    def prog(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["prog"] = str(value)
 
     def todict(self: Self) -> dict[str, Any]:
         "This method returns a dict representing the current instance."
@@ -64,56 +69,63 @@ class PreparseWarning(Warning, Copyable):
 
 class PreparseDualWarning(PreparseWarning):
 
-    args: tuple[str]
-    option: str
-    prog: str
-
     @setdoc.basic
     def __init__(self: Self, *, islong: Any, option: Any, prog: Any) -> None:
         self.prog = prog
         self.option = option
         self.islong = islong
 
+    @staticmethod
+    @abstractmethod
+    def _longmsg() -> str: ...
+    @staticmethod
+    @abstractmethod
+    def _shortmsg() -> str: ...
+
     def getmsg(self: Self) -> str:
         "This method returns the core message."
         if self.islong:
-            return type(self)._longmsg % self.option
+            return self._longmsg() % self.option
         else:
-            return type(self)._shortmsg % self.option
+            return self._shortmsg() % self.option
 
-    @dataprop
-    def islong(self: Self, value: Any) -> bool:
-        return bool(value)
+    @property
+    def islong(self: Self) -> bool:
+        return self._data["islong"]  # type: ignore[no-any-return]
+
+    @islong.setter
+    def islong(self: Self, value: Any) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["islong"] = bool(value)
 
 
 class PreparseInvalidOptionWarning(PreparseDualWarning):
-    args: tuple[str]
-    option: str
-    prog: str
-    _longmsg = "unrecognized option '%s'"
-    _shortmsg = "invalid option -- '%s'"
+    @staticmethod
+    def _longmsg() -> str:
+        return "unrecognized option '%s'"
+
+    @staticmethod
+    def _shortmsg() -> str:
+        return "invalid option -- '%s'"
 
 
 class PreparseRequiredArgumentWarning(PreparseDualWarning):
-    args: tuple[str]
-    option: str
-    prog: str
-    _longmsg = "option '%s' requires an argument"
-    _shortmsg = "option requires an argument -- '%s'"
+
+    @staticmethod
+    def _longmsg() -> str:
+        return "option '%s' requires an argument"
+
+    @staticmethod
+    def _shortmsg() -> str:
+        return "option requires an argument -- '%s'"
 
 
 class PreparseLongonlyWarning(PreparseWarning):
-    args: tuple[str]
-    option: str
-    prog: str
+    pass
     # only possible for long options
 
 
 class PreparseAmbiguousOptionWarning(PreparseLongonlyWarning):
-    args: tuple[str]
-    option: str
-    possibilities: tuple[str, ...]
-    prog: str
 
     @setdoc.basic
     def __init__(
@@ -132,15 +144,18 @@ class PreparseAmbiguousOptionWarning(PreparseLongonlyWarning):
             ans += " '%s'" % x
         return ans
 
-    @dataprop
-    def possibilities(self: Self, value: Iterable[Any]) -> tuple[str, ...]:
-        return tuple(map(str, value))
+    @property
+    def possibilities(self: Self) -> tuple[str, ...]:
+        return self._data["possibilities"]  # type: ignore[no-any-return]
+
+    @possibilities.setter
+    def possibilities(self: Self, value: Iterable[Any]) -> None:
+        self._data = getattr(self, "_data", dict())
+        self._data["possibilities"] = tuple(map(str, value))
 
 
 class PreparseUnallowedArgumentWarning(PreparseLongonlyWarning):
-    args: tuple[str]
-    option: str
-    prog: str
+
     # option is always full key without value
 
     @setdoc.basic

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/tests/test_data_toml.py

@@ -6,23 +6,11 @@ import unittest
 from importlib import resources
 from typing import Any, Self
 
-from preparse.core import (
-    Click,
-    Nargs,
-    Optdict,
-    PreparseAmbiguousOptionWarning,
-    PreparseInvalidOptionWarning,
-    PreParser,
-    PreparseRequiredArgumentWarning,
-    PreparseUnallowedArgumentWarning,
-    PreparseWarning,
-    Tuning,
-    enums,
-    warnings,
-)
+from preparse.core import PreParser
 
 
 class utils:
+    @staticmethod
     def get_data() -> dict[str, Any]:
         data: dict[str, Any]
         text: str
@@ -30,6 +18,7 @@ class utils:
         data = tomllib.loads(text)
         return data
 
+    @staticmethod
     def istestable(x: Any) -> bool:
         if not isinstance(x, float):
             return True

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/tests/test_expit_toml.py

@@ -9,24 +9,12 @@ from typing import Any, Self
 import click
 from click.testing import CliRunner
 
-from preparse.core import (
-    Click,
-    Nargs,
-    Optdict,
-    PreparseAmbiguousOptionWarning,
-    PreparseInvalidOptionWarning,
-    PreParser,
-    PreparseRequiredArgumentWarning,
-    PreparseUnallowedArgumentWarning,
-    PreparseWarning,
-    Tuning,
-    enums,
-    warnings,
-)
+from preparse.core import PreParser
 
 
 class expit:
 
+    @staticmethod
     def function(x: float) -> float:
         p: float
         try:
@@ -35,7 +23,7 @@ class expit:
             p = float("+inf")
         return 1 / (1 + p)
 
-    @PreParser(reconcilesorders=True, expectsposix=False).click()
+    @PreParser(reconcilesorders=True, expectsposix=False).click()  # type: ignore
     @click.command(add_help_option=False)
     @click.help_option("-h", "--help")
     @click.version_option("1.2.3", "-V", "--version")
@@ -46,6 +34,7 @@ class expit:
 
 
 class utils:
+    @staticmethod
     def get_data() -> dict[str, Any]:
         data: dict[str, Any]
         text: str
@@ -53,6 +42,7 @@ class utils:
         data = tomllib.loads(text)
         return data
 
+    @staticmethod
     def istestable(x: Any) -> bool:
         if not isinstance(x, float):
             return True

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse/tests/test_optdict.py

@@ -3,15 +3,7 @@ __all__: list[str] = ["TestPreparse"]
 import unittest
 from typing import Self
 
-from preparse.core.enums import Nargs, Tuning
 from preparse.core.Optdict import Optdict
-from preparse.core.warnings import (
-    PreparseAmbiguousOptionWarning,
-    PreparseInvalidOptionWarning,
-    PreparseRequiredArgumentWarning,
-    PreparseUnallowedArgumentWarning,
-    PreparseWarning,
-)
 
 
 class TestPreparse(unittest.TestCase):

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse.egg-info/PKG-INFO

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

{preparse-1.0.13.post1.dev0 → preparse-1.0.13.post2}/src/preparse.egg-info/SOURCES.txt

@@ -23,8 +23,6 @@ src/preparse/_processing/deparsing.py
 src/preparse/_processing/digesting.py
 src/preparse/_processing/parsing.py
 src/preparse/_processing/pulling.py
-src/preparse/_utils/__init__.py
-src/preparse/_utils/dataprop.py
 src/preparse/core/Click.py
 src/preparse/core/Optdict.py
 src/preparse/core/PreParser.py

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

@@ -1,37 +0,0 @@
-__all__: list[str] = ["Option"]
-
-import operator
-from typing import Any, Self, SupportsIndex
-
-from preparse._items.Item import Item
-from preparse._utils.dataprop import dataprop
-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)
-
-    @dataprop
-    def joined(self: Self, x: SupportsIndex) -> bool:
-        return bool(operator.index(x))
-
-    @dataprop
-    def nargs(self: Self, x: Any) -> Nargs:
-        return Nargs(x)
-
-    @dataprop
-    def right(self: Self, x: Any) -> str | None:
-        if x is not None:
-            return str(x)
-
-    @classmethod
-    def sortkey(cls: type[Self]) -> int:
-        return 0

preparse-1.0.13.post1.dev0/src/preparse/_utils/__init__.py

@@ -1,3 +0,0 @@
-__all__: list[str] = ["dataprop"]
-
-from preparse._utils.dataprop import dataprop

preparse-1.0.13.post1.dev0/src/preparse/_utils/dataprop.py

@@ -1,23 +0,0 @@
-__all__: list[str] = ["dataprop"]
-
-from collections.abc import Callable
-from typing import Any, Self
-
-
-def dataprop(func: Callable[..., Any]) -> property:
-    "This magic method implements calling the current instance."
-
-    kwargs: dict[str, Any]
-
-    def fget(self: Self) -> Any:
-        return self._data[func.__name__]
-
-    def fset(self: Self, value: Any) -> None:
-        self._data = getattr(self, "_data", dict())
-        self._data[func.__name__] = func(self, value)
-
-    kwargs = dict()
-    kwargs["doc"] = func.__doc__
-    kwargs["fget"] = fget
-    kwargs["fset"] = fset
-    return property(**kwargs)