preparse 1.1.8__tar.gz → 1.1.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 1.1.8
+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.8 → preparse-1.1.9}/docs/v1.1.rst

@@ -76,8 +76,8 @@ Features
 
 This dataclass provides decorators for embedding a ``PreParser`` object.
 
-``__call__(target: types.FunctionType) -> types.FunctionType`` ``__call__(target: types.MethodType) -> types.MethodType`` ``__call__(target: types.TargetParser) -> types.TargetParser``
-""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+``__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``.
@@ -90,25 +90,27 @@ This ``property`` determines if the ``reflectClickCommand`` method of parser is
 ``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.PreParser``
-""""""""""""""""""""""""""""""
+``parser: preparse.core.PreParser.PreParser``
+"""""""""""""""""""""""""""""""""""""""""""""
 
 This ``property`` holds the parser to be embedded.
 
-``class preparse.core.Optdict.Optdict``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``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: Any = (), prog: object = None, reconcilesorders: object = True, special: int = preparse.Tuning.MAINTAIN, warn: Callable[[PreparseWarning], Any] = str)``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``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``.
@@ -126,7 +128,7 @@ 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: object = True, ctx: object = True) -> preparse.Click``
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
@@ -152,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``
 """""""""""""""""""""""""""""
@@ -165,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.
@@ -178,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``
 """""""""""""""""""""""""""""""""""""""""""""""""""
@@ -206,13 +212,13 @@ 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.
@@ -249,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.             |
 +-------------------+-------+----------------------------------------------+
 
+``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.warnings.PreparseWarning.PreparseWarning``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+``class preparse.warnings.PreparseWarning.PreparseWarning(**kwargs: Any)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 This abstract base ``class`` is the base for all other warning types.
 
-``class preparse.warnings.PreparseAmbiguousOptionWarning.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.warnings.PreparseInvalidOptionWarning.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.warnings.PreparseRequiredArgumentWarning.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.warnings.PreparseUnallowedArgumentWarning.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.
 
-``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()
-
 License
 -------
 

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

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

{preparse-1.1.8 → 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.8 → 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.8 → 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.8 → 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"]
@@ -35,7 +36,9 @@ class PreParser(Copyable):
         expandsabbr: object = True,
         expectsabbr: object = True,
         expectsposix: object = False,
-        optdict: Any = (),
+        optdict: (
+            SupportsKeysAndGetitem | Iterable[tuple[Hashable, object]]
+        ) = (),
         prog: object = None,
         reconcilesorders: object = True,
         special: int = Tuning.MAINTAIN,

{preparse-1.1.8 → 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.8 → 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.8 → 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.8 → 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.8 → preparse-1.1.9}/src/preparse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 1.1.8
+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.8 → preparse-1.1.9}/src/preparse.egg-info/SOURCES.txt

@@ -42,7 +42,6 @@ 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/Parser.py
 src/preparse/typing/SupportsKeysAndGetitem.py
 src/preparse/typing/__init__.py
 src/preparse/warnings/PreparseAmbiguousOptionWarning.py

preparse-1.1.8/src/preparse/typing/Parser.py

@@ -1,5 +0,0 @@
-from typing import Any, Callable, Protocol
-
-
-class Parser(Protocol):
-    parse_args: Callable[..., Any]