preparse 1.1.7__tar.gz → 1.1.9__tar.gz

{preparse-1.1.7 → preparse-1.1.9}/PKG-INFO

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

{preparse-1.1.7 → preparse-1.1.9}/docs/v1.1.rst

@@ -68,11 +68,49 @@ how ``preparse`` can be used to modify ``click``.
 Features
 --------
 
-The ``PreParser`` class
-~~~~~~~~~~~~~~~~~~~~~~~
+``preparse.core``
+~~~~~~~~~~~~~~~~~
+
+``class preparse.core.Click.Click(parser: preparse.PreParser, cmd: object = True, ctx: object = True)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This dataclass provides decorators for embedding a ``PreParser`` object.
+
+``__call__(target: types.FunctionType) -> types.FunctionType`` ``__call__(target: types.MethodType) -> types.MethodType`` ``__call__(target: typing.Any) -> typing.Any``
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+This magic method implements ``self(target)``.
+It works as a decorator that embeds its parser into a given target from the library ``click``.
+
+``cmd: object``
+"""""""""""""""
+
+This ``property`` determines if the ``reflectClickCommand`` method of parser is to be called.
+
+``copy() -> Self``
+""""""""""""""""""
+
+This method returns a shallow copy of the current decorator.
+
+``ctx: object``
+"""""""""""""""
+
+This ``property`` determines if the ``reflectClickContext`` method of parser is to be called.
+
+``parser: preparse.core.PreParser.PreParser``
+"""""""""""""""""""""""""""""""""""""""""""""
+
+This ``property`` holds the parser to be embedded.
 
-``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.core.Optdict.Optdict(data: preparse.typing.SupportsKeysAndGetitem.SupportsKeysAndGetitem | Iterable[tuple[Hashable, object]] = (), /)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+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``.
+
+``class preparse.core.PreParser.PreParser(*, allowslong: object = True, allowsshort: object = True, bundling: int = Tuning.MAINTAIN, expandsabbr: object = True, expectsabbr: object = True, expectsposix: object = False, optdict: preparse.typing.SupportsKeysAndGetitem.SupportsKeysAndGetitem | Iterable[tuple[Hashable, object]] = (), prog: object = None, reconcilesorders: object = True, special: int = preparse.Tuning.MAINTAIN, warn: Callable[[PreparseWarning], Any] = str)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This ``class`` is the centerpiece of the ``preparse``.
 Its behaviour follows the principles of ``getopt`` from ``C``.
@@ -90,10 +128,10 @@ This boolean ``property`` determines whether short options are allowed.
 ``bundling: preparse.Tuning``
 """""""""""""""""""""""""""""
 
-This ``property`` determines the approach to bundling of short option.
+This ``property`` determines the approach to bundling of short options.
 
-``click(cmd: Any = True, ctx: Any = True) -> preparse.Click``
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+``click(cmd: object = True, ctx: object = True) -> preparse.Click``
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
 This method returns a decorator that infuses the current instance into ``parse_args``.
 
@@ -116,8 +154,10 @@ This boolean ``property`` determines whether abbreviations of long options are e
 ``expectsposix: bool``
 """"""""""""""""""""""
 
-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.
+This boolean ``property`` determines whether the order of arguments conforms to the POSIX standard,
+i.e. all arguments after the first positional argument are also positional.
+If the value passed to the property is ``"infer"``, the value is inferred from
+the ``POSIXLY_CORRECT`` environment variable.
 
 ``optdict: preparse.Optdict``
 """""""""""""""""""""""""""""
@@ -129,8 +169,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: Optional[Iterable[object]] = None) -> list[str]``
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
 This method is at the core of the class.
 It returns a preparsed list of arguments.
@@ -142,19 +182,21 @@ there will be no changes after the first run.
 """""""""""""
 
 This ``str`` property represents the name of the program.
-If the value passed to the property is ``None`` then ``str(sys.argv[0])`` is saved.
+If the value passed to the property is ``None`` then ``str(os.path.basename(sys.argv[0]))`` is saved.
 
 ``reconcilesorders: bool``
 """"""""""""""""""""""""""
 
-This boolean ``property`` determines whether compatibility with both orders,
-POSIX and the interleaving of options with positonal arguments, should be enforced.
+This boolean ``property`` determines whether compatibility with both POSIX ordering
+and interleaving options with positional arguments should be enforced.
 
 ``reflectClickCommand(cmd: click.Command) -> None``
 """""""""""""""""""""""""""""""""""""""""""""""""""
 
 This method alters the current instance to reflect a ``click.Command`` object.
 Concretely the ``optdict`` property is changed.
+Only entries in each Click option's ``opts`` are reflected; secondary option names
+are not added.
 
 ``reflectClickContext(ctx: click.Context) -> None``
 """""""""""""""""""""""""""""""""""""""""""""""""""
@@ -170,67 +212,25 @@ This ``property`` determines the approach to the special argument ``'--'``.
 ``todict() -> dict[str, Any]``
 """"""""""""""""""""""""""""""
 
-This method a ``dict`` representing the current instance.
+This method returns a ``dict`` representing the current instance.
 
 ``warn: Callable[[PreparseWarning], Any]``
 """"""""""""""""""""""""""""""""""""""""""
 
 This property holds a function that is called whenever ``parse_args`` encounters a warning.
-The warning is given as the only positional arguments.
+The warning is given as the only positional argument.
 No keyword arguments are given.
 Its return value is discarded.
 Therefore, ``str`` is used to discard the warnings.
 
-The Click class
-~~~~~~~~~~~~~~~
-
-``class preparse.Click(parser: preparse.PreParser, cmd: Any = True, ctx: Any = True)``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-This dataclass provides decorators for embedding a ``PreParser`` object.
-
-``__call__(target: Any) -> Any``
-""""""""""""""""""""""""""""""""
-
-This magic method implements ``self(target)``.
-It works as a decorator that embeds its parser into a given target from the library ``click``.
-
-``cmd: Any``
-""""""""""""
-
-This ``property`` determines if the ``reflectClickCommand`` method of parser is to be called.
-
-``copy() -> Self``
-""""""""""""""""""
-
-``ctx: Any``
-""""""""""""
-
-This ``property`` determines if the ``reflectClickContext`` method of parser is to be called.
-
-``parser: preparse.PreParser``
-""""""""""""""""""""""""""""""
-
-This ``property`` holds the parser to be embedded.
-
-The Optdict class
-~~~~~~~~~~~~~~~~~
-
-``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``.
-
-The Enums
-~~~~~~~~~
+``preparse.enums``
+~~~~~~~~~~~~~~~~~~
 
 These classes are subclasses of ``enum.IntEnum``.
 Any value different from ``0`` (meaning no) and ``1`` (meaning yes) is interpreted as ``2`` (meaning intermediate).
 
-``class preparse.Tuning``
-^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.enums.Tuning.Tuning``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 +--------------+-------+-----------------------------------------------------------------------------+
 | Name         | Value | Explanation                                                                 |
@@ -242,8 +242,8 @@ Any value different from ``0`` (meaning no) and ``1`` (meaning yes) is interpret
 | ``MAINTAIN`` | ``2`` | The PreParser does not make any unforced changes to the aspect in question. |
 +--------------+-------+-----------------------------------------------------------------------------+
 
-``class preparse.Nargs``
-^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.enums.Nargs.Nargs``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 +-------------------+-------+----------------------------------------------+
 | Name              | Value | Explanation                                  |
@@ -255,49 +255,63 @@ Any value different from ``0`` (meaning no) and ``1`` (meaning yes) is interpret
 | OPTIONAL_ARGUMENT | ``2`` | The option may take an argument.             |
 +-------------------+-------+----------------------------------------------+
 
-The Warnings
-~~~~~~~~~~~~
+``preparse.tests``
+~~~~~~~~~~~~~~~~~~
+
+``preparse.tests.test() -> unittest.TextTestResult``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This project can be tested through its ``test`` function.
+
+.. code-block:: python
+
+    import preparse.tests
+    preparse.tests.test()
+
+``preparse.typing``
+~~~~~~~~~~~~~~~~~~~
+
+``class preparse.typing.SupportsKeysAndGetitem.SupportsKeysAndGetitem``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This protocol is included in the project for type annotation.
+
+``__getitem__(key: Hashable, /) -> object``
+"""""""""""""""""""""""""""""""""""""""""""
+
+``keys() -> tuple[Hashable, ...]``
+""""""""""""""""""""""""""""""""""
+
+``preparse.warnings``
+~~~~~~~~~~~~~~~~~~~~~
 
 These classes are subclasses of ``Warning`` that are specifically designed to communicate issues with parsing.
 
-``class preparse.PreparseWarning``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.warnings.PreparseWarning.PreparseWarning(**kwargs: Any)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This abstract base ``class`` is the base for all other warning types.
 
-``class preparse.PreparseAmbiguousOptionWarning(prog: Any, option: Any, possibilities: Any)``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.warnings.PreparseAmbiguousOptionWarning.PreparseAmbiguousOptionWarning(*, prog: Any, option: Any, possibilities: Any)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This ``class`` warns about ambiguous options. This can only happen for long options.
 
-``class preparse.PreparseInvalidOptionWarning(prog: Any, option: Any, islong: Any)``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.warnings.PreparseInvalidOptionWarning.PreparseInvalidOptionWarning(*, prog: object, option: object, islong: object)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This ``class`` warns about invalid options.
 
-``class preparse.PreparseRequiredArgumentWarning(prog: Any, option: Any, islong: Any)``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.warnings.PreparseRequiredArgumentWarning.PreparseRequiredArgumentWarning(*, prog: object, option: object, islong: object)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This ``class`` warns about missing required arguments.
 
-``class preparse.PreparseUnallowedArgumentWarning(prog: Any, option: Any)``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.warnings.PreparseUnallowedArgumentWarning.PreparseUnallowedArgumentWarning(*, prog: object, option: object)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This ``class`` warns about unallowed arguments. This can only happen for long options.
 
-The Tests
-~~~~~~~~~
-
-``preparse.tests.test() -> unittest.TextTestResult``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-This project can be tested through its ``test`` function.
-
-.. code-block:: python
-
-    import preparse.tests
-    preparse.tests.test()
-
 License
 -------
 

{preparse-1.1.7 → preparse-1.1.9}/pyproject.toml

@@ -36,7 +36,7 @@ license-files = [
 name = "preparse"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.1.7"
+version = "1.1.9"
 
 [project.urls]
 Download = "https://pypi.org/project/preparse/#files"

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/__init__.py

@@ -1,3 +1,5 @@
+from preparse.core.Click import Click
+from preparse.core.Optdict import Optdict
 from preparse.core.PreParser import PreParser
 from preparse.enums.Nargs import Nargs
 from preparse.enums.Tuning import Tuning
@@ -14,3 +16,16 @@ from preparse.warnings.PreparseUnallowedArgumentWarning import (
     PreparseUnallowedArgumentWarning,
 )
 from preparse.warnings.PreparseWarning import PreparseWarning
+
+__all__ = [
+    "PreParser",
+    "Optdict",
+    "Click",
+    "Nargs",
+    "Tuning",
+    "PreparseAmbiguousOptionWarning",
+    "PreparseInvalidOptionWarning",
+    "PreparseRequiredArgumentWarning",
+    "PreparseUnallowedArgumentWarning",
+    "PreparseWarning",
+]

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/_items/Bundle.py

@@ -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[Self], chars: str) -> list[str]:
         ans: list[str]
         x: str
         ans = list()
@@ -44,7 +44,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()

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/_items/Long.py

@@ -60,7 +60,7 @@ class Long(Option):
         return self._fullkey
 
     @fullkey.setter
-    def fullkey(self: Self, x: Any) -> None:
+    def fullkey(self: Self, x: object) -> None:
         self._fullkey = str(x)
 
     @classmethod

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/_processing/digesting.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, cast
 
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
@@ -154,7 +154,7 @@ def digest_special(
     items: list[Item],
     *,
     special: Tuning,
-    **kwargs: Any,
+    **kwargs: bool,
 ) -> list[Item]:
     if special == Tuning.MINIMIZE:
         return digest_special_min(items, **kwargs)

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/core/Click.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import dataclasses
 import functools
-import types
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, Self
+from types import FunctionType, MethodType
+from typing import TYPE_CHECKING, Any, Self, cast, overload
 
 import setdoc
 from copyable import Copyable
@@ -19,18 +19,36 @@ __all__ = ["Click"]
 class Click(Copyable):
 
     parser: PreParser
-    cmd: Any = True
-    ctx: Any = True
+    cmd: object = True
+    ctx: object = True
 
+    @overload
+    def __call__(self: Self, target: FunctionType) -> FunctionType:
+        "This magic method implements self(target)."
+        ...
+
+    @overload
+    def __call__(self: Self, target: MethodType) -> MethodType:
+        "This magic method implements self(target)."
+        ...
+
+    @overload
     def __call__(self: Self, target: Any) -> Any:
         "This magic method implements self(target)."
-        if isinstance(target, types.FunctionType):
+        ...
+
+    def __call__(
+        self: Self,
+        target: Any,
+    ) -> Any:
+        "This magic method implements self(target)."
+        if isinstance(target, FunctionType):
             return self._call_function(target)
-        if isinstance(target, types.MethodType):
+        if isinstance(target, MethodType):
             return self._call_method(target)
         return self._call_other(target)
 
-    def _call_function(self: Self, target: types.FunctionType) -> Any:
+    def _call_function(self: Self, target: FunctionType) -> FunctionType:
         @functools.wraps(target)
         def ans(cmd: Any, ctx: Any, args: Any) -> Any:
             p: Any
@@ -41,12 +59,12 @@ class Click(Copyable):
                 p.reflectClickContext(ctx)
             return target(cmd, ctx, p.parse_args(args))
 
-        return ans
+        return cast(FunctionType, ans)
 
-    def _call_method(self: Self, target: types.MethodType) -> types.MethodType:
+    def _call_method(self: Self, target: MethodType) -> MethodType:
         func: Callable[..., Any]
         func = self(target.__func__)
-        return types.MethodType(func, target.__self__)
+        return MethodType(func, target.__self__)
 
     def _call_other(self: Self, target: Any) -> Any:
         target.parse_args = self(target.parse_args)

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/core/Optdict.py

@@ -1,13 +1,13 @@
-from collections.abc import Hashable
+from collections.abc import Hashable, Iterable
 from typing import Any, Optional, Self, cast
 
 import cmp3
 import datahold
 import setdoc
-from datarepr import datarepr
 from frozendict import frozendict
 
 from preparse.enums.Nargs import Nargs
+from preparse.typing.SupportsKeysAndGetitem import SupportsKeysAndGetitem
 
 __all__ = ["Optdict"]
 
@@ -19,7 +19,10 @@ def nargs(value: Any, /) -> Nargs:
         return Nargs.OPTIONAL_ARGUMENT
 
 
-class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
+class Optdict(
+    cmp3.CmpABC,
+    datahold.HoldDict[str, Nargs],
+):
     __slots__ = ()
 
     _data: frozendict[str, Nargs]
@@ -36,28 +39,22 @@ class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
                 Optional[int], cmp3.cmp(self._data, other, mode="eq_strict")
             )
 
-    __format__ = object.__format__
+    __init__ = datahold.HoldDict[Hashable, object].__init__
 
-    @setdoc.basic
-    def __init__(self: Self, data: Any = (), /) -> None:
-        datahold.HoldDict.__init__(self, data)
-
-    @setdoc.basic
-    def __repr__(self: Self, /) -> str:
-        return datarepr(type(self).__name__, dict(self._data))
-
-    __str__ = object.__str__
-
-    @property  # type: ignore[override]
+    @property
     def data(self: Self) -> frozendict[str, Nargs]:
         return frozendict(self._data)
 
-    @data.setter
-    def data(self: Self, value: Any) -> None:
+    @data.setter  # type: ignore[override]
+    def data(
+        self: Self,
+        value: SupportsKeysAndGetitem | Iterable[tuple[Hashable, object]],
+        /,
+    ) -> None:
         a: frozendict[Hashable, object]
         x: map[str]
         y: map[Nargs]
-        a = frozendict(value)
+        a = frozendict(value)  # type: ignore[arg-type]
         x = map(str, a.keys())
         y = map(nargs, a.values())
         self._data = frozendict(zip(x, y, strict=True))

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/core/PreParser.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 import sys
-from collections.abc import Callable, Iterable
+from collections.abc import Callable, Hashable, Iterable
 from typing import Any, Optional, Self, cast
 
 import click as cl
@@ -16,6 +16,7 @@ from preparse.core.Click import Click
 from preparse.core.Optdict import Optdict
 from preparse.enums.Nargs import Nargs
 from preparse.enums.Tuning import Tuning
+from preparse.typing.SupportsKeysAndGetitem import SupportsKeysAndGetitem
 from preparse.warnings.PreparseWarning import PreparseWarning
 
 __all__ = ["PreParser"]
@@ -29,17 +30,19 @@ class PreParser(Copyable):
     def __init__(
         self: Self,
         *,
-        allowslong: Any = True,
-        allowsshort: Any = True,
-        bundling: Any = Tuning.MAINTAIN,
-        expandsabbr: Any = True,
-        expectsabbr: Any = True,
-        expectsposix: Any = False,
-        optdict: Any = (),
+        allowslong: object = True,
+        allowsshort: object = True,
+        bundling: int = Tuning.MAINTAIN,
+        expandsabbr: object = True,
+        expectsabbr: object = True,
+        expectsposix: object = False,
+        optdict: (
+            SupportsKeysAndGetitem | Iterable[tuple[Hashable, object]]
+        ) = (),
         prog: object = None,
-        reconcilesorders: Any = True,
-        special: Any = Tuning.MAINTAIN,
-        warn: Callable = str,  # type: ignore[type-arg]
+        reconcilesorders: object = True,
+        special: int = Tuning.MAINTAIN,
+        warn: Callable[[PreparseWarning], Any] = str,
     ) -> None:
         self._data: dict[str, Any]
         self._data = dict()
@@ -64,7 +67,7 @@ class PreParser(Copyable):
         return cast(bool, self._data["allowslong"])
 
     @allowslong.setter
-    def allowslong(self: Self, value: Any) -> None:
+    def allowslong(self: Self, value: object) -> None:
         self._data["allowslong"] = bool(value)
 
     @property
@@ -72,7 +75,7 @@ class PreParser(Copyable):
         return cast(bool, self._data["allowsshort"])
 
     @allowsshort.setter
-    def allowsshort(self: Self, value: Any) -> None:
+    def allowsshort(self: Self, value: object) -> None:
         self._data["allowsshort"] = bool(value)
 
     @property
@@ -85,7 +88,7 @@ class PreParser(Copyable):
         "This property decides how to approach the bundling of short options."
         self._data["bundling"] = Tuning(value)
 
-    def click(self: Self, cmd: Any = True, ctx: Any = True) -> Click:
+    def click(self: Self, cmd: object = True, ctx: object = True) -> Click:
         "This method returns a decorator that infuses the current instance into parse_args."
         return Click(parser=self, cmd=cmd, ctx=ctx)
 
@@ -98,7 +101,7 @@ class PreParser(Copyable):
         return cast(bool, self._data["expandsabbr"])
 
     @expandsabbr.setter
-    def expandsabbr(self: Self, value: Any, /) -> None:
+    def expandsabbr(self: Self, value: object, /) -> None:
         self._data["expandsabbr"] = bool(value)
 
     @property
@@ -106,7 +109,7 @@ class PreParser(Copyable):
         return cast(bool, self._data["expectsabbr"])
 
     @expectsabbr.setter
-    def expectsabbr(self: Self, value: Any) -> None:
+    def expectsabbr(self: Self, value: object) -> None:
         self._data["expectsabbr"] = bool(value)
 
     @property
@@ -114,7 +117,7 @@ class PreParser(Copyable):
         return cast(bool, self._data["expectsposix"])
 
     @expectsposix.setter
-    def expectsposix(self: Self, value: Any) -> None:
+    def expectsposix(self: Self, value: object) -> None:
         value_: Any
         if value == "infer":
             value_ = os.environ.get("POSIXLY_CORRECT")
@@ -162,7 +165,7 @@ class PreParser(Copyable):
         return cast(bool, self._data["reconcilesorders"])
 
     @reconcilesorders.setter
-    def reconcilesorders(self: Self, value: Any, /) -> None:
+    def reconcilesorders(self: Self, value: object, /) -> None:
         self._data["reconcilesorders"] = bool(value)
 
     def reflectClickCommand(self: Self, cmd: cl.Command) -> None:

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/tests/test_optdict.py

@@ -2,6 +2,7 @@ import unittest
 from typing import Self
 
 from preparse.core.Optdict import Optdict
+from preparse.enums.Nargs import Nargs
 
 __all__ = ["TestPreparse"]
 
@@ -15,6 +16,15 @@ class TestPreparse(unittest.TestCase):
         dublicate = original.copy()
         self.assertEqual(original, dublicate)
 
+    def test_optdict_repr(self: Self) -> None:
+        data: dict[str, Nargs]
+        original: Optdict
+        data = {"--foo": Nargs.NO_ARGUMENT, "-bar": Nargs.REQUIRED_ARGUMENT}
+        original = Optdict(data)
+        self.assertEqual(repr(original), f"Optdict({data})")
+        self.assertEqual(repr(original), str(original))
+        self.assertEqual(repr(original), format(original))
+
 
 if __name__ == "__main__":
     unittest.main()

preparse-1.1.9/src/preparse/typing/SupportsKeysAndGetitem.py

@@ -0,0 +1,9 @@
+from collections.abc import Hashable
+from typing import Protocol, Self
+
+__all__ = ["SupportsKeysAndGetitem"]
+
+
+class SupportsKeysAndGetitem(Protocol):
+    def __getitem__(self: Self, key: Hashable, /) -> object: ...
+    def keys(self: Self) -> tuple[Hashable, ...]: ...

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/warnings/PreparseAmbiguousOptionWarning.py

@@ -14,8 +14,8 @@ class PreparseAmbiguousOptionWarning(PreparseLongonlyWarning):
     def __post_init__(
         self: Self,
         *,
-        prog: Any,
-        option: Any,
+        prog: object,
+        option: object,
         possibilities: Iterable[object],
     ) -> None:
         self.prog = prog
@@ -36,5 +36,5 @@ class PreparseAmbiguousOptionWarning(PreparseLongonlyWarning):
         return cast(tuple[str, ...], self._data["possibilities"])
 
     @possibilities.setter
-    def possibilities(self: Self, value: Iterable[object]) -> None:
+    def possibilities(self: Self, value: Iterable[object], /) -> None:
         self._data["possibilities"] = tuple(map(str, value))

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/warnings/PreparseDualWarning.py

@@ -12,7 +12,11 @@ class PreparseDualWarning(PreparseWarning):
 
     @setdoc.basic
     def __post_init__(
-        self: Self, *, prog: Any, option: Any, islong: Any
+        self: Self,
+        *,
+        prog: object,
+        option: object,
+        islong: object,
     ) -> None:
         self.prog = prog
         self.option = option
@@ -38,5 +42,5 @@ class PreparseDualWarning(PreparseWarning):
         return cast(bool, self._data["islong"])
 
     @islong.setter
-    def islong(self: Self, value: Any) -> None:
+    def islong(self: Self, value: object, /) -> None:
         self._data["islong"] = bool(value)

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/warnings/PreparseUnallowedArgumentWarning.py

@@ -12,7 +12,7 @@ class PreparseUnallowedArgumentWarning(PreparseLongonlyWarning):
     # option is always full key without value
 
     @setdoc.basic
-    def __post_init__(self: Self, *, prog: Any, option: Any) -> None:
+    def __post_init__(self: Self, *, prog: object, option: object) -> None:
         self.prog = prog
         self.option = option
 

{preparse-1.1.7 → preparse-1.1.9}/src/preparse/warnings/PreparseWarning.py

@@ -42,7 +42,7 @@ class PreparseWarning(Warning, Copyable):
         return cast(str, self._data["option"])
 
     @option.setter
-    def option(self: Self, value: object) -> None:
+    def option(self: Self, value: object, /) -> None:
         self._data["option"] = str(value)
 
     @property
@@ -50,7 +50,7 @@ class PreparseWarning(Warning, Copyable):
         return cast(str, self._data["prog"])
 
     @prog.setter
-    def prog(self: Self, value: object) -> None:
+    def prog(self: Self, value: object, /) -> None:
         self._data["prog"] = str(value)
 
     def todict(self: Self) -> dict[str, Any]:

{preparse-1.1.7 → preparse-1.1.9}/src/preparse.egg-info/PKG-INFO

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

{preparse-1.1.7 → preparse-1.1.9}/src/preparse.egg-info/SOURCES.txt

@@ -42,6 +42,8 @@ src/preparse/tests/test_enums.py
 src/preparse/tests/test_expit_toml.py
 src/preparse/tests/test_optdict.py
 src/preparse/tests/test_preparser.py
+src/preparse/typing/SupportsKeysAndGetitem.py
+src/preparse/typing/__init__.py
 src/preparse/warnings/PreparseAmbiguousOptionWarning.py
 src/preparse/warnings/PreparseDualWarning.py
 src/preparse/warnings/PreparseInvalidOptionWarning.py