preparse 1.1.2__tar.gz → 1.1.4__tar.gz

{preparse-1.1.2 → preparse-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 1.1.2
+Version: 1.1.4
 Summary: This project preparses args for further parsing later on.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT
@@ -21,10 +21,10 @@ License-File: LICENSE.txt
 Requires-Dist: click<9,>=8.2
 Requires-Dist: cmp3<2,>=1.0
 Requires-Dist: copyable<2,>=1.1
-Requires-Dist: datahold<4,>=3.0
+Requires-Dist: datahold<4,>=3.0.34.dev1
 Requires-Dist: datarepr<2,>=1.2
 Requires-Dist: frozendict<3,>=2.4.7
-Requires-Dist: setdoc<2,>=1.2.20
+Requires-Dist: setdoc<2,>=1.3
 Requires-Dist: tofunc<2,>=1.1
 Dynamic: license-file
 

{preparse-1.1.2 → preparse-1.1.4}/docs/v1.1.rst

@@ -1,13 +1,14 @@
 Overview
 --------
 
-The preparse project allows to preparse arguments before the main parsing.
+The ``preparse`` project allows to preparse arguments before the main parsing.
 Its ability to deabbreviate options is especially useful for use with ``click``.
 
 Installation
 ------------
 
-To install preparse, you can use pip. Open your terminal and run:
+To install ``preparse``, you can use ``pip``.
+Open your terminal and run:
 
 .. code-block:: shell
 
@@ -25,11 +26,16 @@ The typing conforms (not strictly) to ``mypy``.
 Introduction
 ------------
 
-The preparse project allows for preprocessing a list of arguments so that they can be parsed definitively in a later step. This way, the functionality of another parsing system can be modified. The project is especially adapted to work with the click project.
+The ``preparse`` project allows for preprocessing a ``list`` of arguments
+so that they can be parsed definitively in a later step.
+This way, the functionality of another parsing system can be modified.
+The project is especially adapted to work with the ``click`` project.
 
-The project preparse is strongly inspired by the getopt and getopt_long libraries within C.
+The project ``preparse`` is strongly inspired
+by the ``getopt`` and ``getopt_long`` libraries within ``C``.
 
-Here is the implementation of the ``expit`` project (Version 1.0.13) to illustrate how preparse can be used to modify click.
+Here is the implementation of the ``expit`` project (Version ``1.0.13``) to illustrate
+how ``preparse`` can be used to modify ``click``.
 
 .. code-block:: python
 
@@ -62,28 +68,29 @@ Here is the implementation of the ``expit`` project (Version 1.0.13) to illustra
 Features
 --------
 
-The PreParser class
-~~~~~~~~~~~~~~~~~~~
+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)``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This class is the centerpiece of the preparse. Its behaviour follows the principles of getopt from C.
+This ``class`` is the centerpiece of the ``preparse``.
+Its behaviour follows the principles of ``getopt`` from ``C``.
 
 ``allowslong: bool``
 """"""""""""""""""""
 
-This boolean property determines whether long options are allowed.
+This boolean ``property`` determines whether long options are allowed.
 
 ``allowsshort: bool``
 """""""""""""""""""""
 
-This boolean property determines whether short options are allowed.
+This boolean ``property`` determines whether short options are allowed.
 
 ``bundling: preparse.Tuning``
 """""""""""""""""""""""""""""
 
-This ``preparse.Tuning`` property determines the approach to bundling of short option.
+This ``property`` determines the approach to bundling of short option.
 
 ``click(cmd: Any = True, ctx: Any = True) -> preparse.Click``
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
@@ -98,22 +105,24 @@ This method returns a copy of the current instance.
 ``expandsabbr: bool``
 """""""""""""""""""""
 
-This boolean property determines whether recognized abbreviations of long options are to be expanded to their full length.
+This boolean ``property`` determines whether recognized abbreviations of long options
+are to be expanded to their full length.
 
 ``expectsabbr: bool``
 """""""""""""""""""""
 
-This boolean property determines whether abbreviations of long options are expected.
+This boolean ``property`` determines whether abbreviations of long options are expected.
 
 ``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 to conform to the POSIX standard,
+i.e. all arguments after the first positional argument also being positonal.
 
 ``optdict: preparse.Optdict``
 """""""""""""""""""""""""""""
 
-This property holds a dict-like object.
+This ``property`` holds a dict-like object.
 Its keys are the options.
 Its values specify ``preparse.Nargs``.
 Options not found within the dictionary
@@ -126,7 +135,8 @@ and are then assumed to have no arguments.
 This method is at the core of the class.
 It returns a preparsed list of arguments.
 If ``None`` is passed as args then ``sys.argv[1:]`` is used.
-If the method is applied repeatedly to a list there will be no changes after the first run.
+If the method is applied repeatedly to a ``list``
+there will be no changes after the first run.
 
 ``prog: str``
 """""""""""""
@@ -137,30 +147,30 @@ If the value passed to the property is ``None`` then ``str(sys.argv[0])`` is sav
 ``reconcilesorders: bool``
 """"""""""""""""""""""""""
 
-This boolean property determines whether compatibility with both orders,
+This boolean ``property`` determines whether compatibility with both orders,
 POSIX and the interleaving of options with positonal 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.
+Concretely the ``optdict`` property is changed.
 
 ``reflectClickContext(ctx: click.Context) -> None``
 """""""""""""""""""""""""""""""""""""""""""""""""""
 
 This method alters the current instance to reflect a ``click.Context`` object.
-Concretely the prog property is changed.
+Concretely the ``prog`` property is changed.
 
 ``special: preparse.Tuning``
 """"""""""""""""""""""""""""
 
-This ``preparse.Tuning`` property determines the approach to the special argument ``'--'``.
+This ``property`` determines the approach to the special argument ``'--'``.
 
-``todict() -> dict``
-""""""""""""""""""""
+``todict() -> dict[str, Any]``
+""""""""""""""""""""""""""""""
 
-This method a dict representing the current instance.
+This method a ``dict`` representing the current instance.
 
 ``warn: types.FunctionType``
 """"""""""""""""""""""""""""
@@ -183,12 +193,12 @@ This dataclass provides decorators for embedding a ``PreParser`` object.
 """"""""""""""""""""""""""""""""
 
 This magic method implements ``self(target)``.
-It works as a decorator that embeds its parser into a given target from the library click.
+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.
+This ``property`` determines if the ``reflectClickCommand`` method of parser is to be called.
 
 ``copy() -> Self``
 """"""""""""""""""
@@ -196,12 +206,12 @@ This property determines if the ``reflectClickCommand`` method of parser is to b
 ``ctx: Any``
 """"""""""""
 
-This property determines if the ``reflectClickContext`` method of parser is to be called.
+This ``property`` determines if the ``reflectClickContext`` method of parser is to be called.
 
 ``parser: preparse.PreParser``
 """"""""""""""""""""""""""""""
 
-This property holds the parser to be embedded.
+This ``property`` holds the parser to be embedded.
 
 The Optdict class
 ~~~~~~~~~~~~~~~~~
@@ -253,27 +263,27 @@ These classes are subclasses of ``Warning`` that are specifically designed to co
 ``class preparse.PreparseWarning``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This abstract base class is the base for all other warning types.
+This abstract base ``class`` is the base for all other warning types.
 
 ``class preparse.PreparseAmbiguousOptionWarning(prog: Any, option: Any, possibilities: Any)``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This class warns about ambiguous options. This can only happen for long options.
+This ``class`` warns about ambiguous options. This can only happen for long options.
 
 ``class preparse.PreparseInvalidOptionWarning(prog: Any, option: Any, islong: Any)``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This class warns about invalid options.
+This ``class`` warns about invalid options.
 
 ``class preparse.PreparseRequiredArgumentWarning(prog: Any, option: Any, islong: Any)``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This class warns about missing required arguments.
+This ``class`` warns about missing required arguments.
 
 ``class preparse.PreparseUnallowedArgumentWarning(prog: Any, option: Any)``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This class warns about unallowed arguments. This can only happen for long options.
+This ``class`` warns about unallowed arguments. This can only happen for long options.
 
 The Tests
 ~~~~~~~~~
@@ -281,7 +291,7 @@ The Tests
 ``preparse.tests.test() -> unittest.TextTestResult``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This project can be tested through its test function.
+This project can be tested through its ``test`` function.
 
 .. code-block:: python
 

{preparse-1.1.2 → preparse-1.1.4}/pyproject.toml

@@ -21,10 +21,10 @@ dependencies = [
     "click>=8.2,<9",
     "cmp3>=1.0,<2",
     "copyable>=1.1,<2",
-    "datahold>=3.0,<4",
+    "datahold>=3.0.34.dev1,<4",
     "datarepr>=1.2,<2",
     "frozendict>=2.4.7,<3",
-    "setdoc>=1.2.20,<2",
+    "setdoc>=1.3,<2",
     "tofunc>=1.1,<2",
 ]
 description = "This project preparses args for further parsing later on."
@@ -36,7 +36,7 @@ license-files = [
 name = "preparse"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.1.2"
+version = "1.1.4"
 
 [project.urls]
 Download = "https://pypi.org/project/preparse/#files"
@@ -50,12 +50,3 @@ files = [
 ]
 python_version = "3.11"
 strict = false
-
-[[tool.mypy.overrides]]
-module = [
-    "cmp3",
-    "cmp3.*",
-    "datahold",
-    "datahold.*",
-]
-ignore_missing_imports = true

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/_processing/__init__.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterable
 from types import FunctionType
-from typing import *
+from typing import Optional
 
 from preparse._items import *
 from preparse._processing.deparsing import *
@@ -13,7 +14,7 @@ __all__ = ["process"]
 
 
 def process(
-    args: Optional[Iterable] = None,
+    args: Optional[Iterable[object]] = None,
     *,
     allowslong: bool,
     allowsshort: bool,

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/_processing/parsing.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterable
 from types import FunctionType
-from typing import *
+from typing import Any, Generator
 
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
@@ -26,7 +27,7 @@ def parse_bundling(
     arg: str,
     *,
     cause: FunctionType,
-    optdict: dict,
+    optdict: dict[Any, Any],
 ) -> Bundle:
     ans: Bundle
     x: int
@@ -67,7 +68,7 @@ def parse_generator(
     allowsshort: bool,
     expectsabbr: bool,
     expectsposix: bool,
-    optdict: dict,
+    optdict: dict[Any, Any],
     prog: str,
     warn: FunctionType,
 ) -> Generator[Any, Any, Any]:
@@ -137,7 +138,7 @@ def parse_long(
     *,
     cause: FunctionType,
     expectsabbr: bool,
-    optdict: dict,
+    optdict: dict[Any, Any],
 ) -> Long:
     ans: Long
     parts: list[str]
@@ -187,7 +188,7 @@ def parse_option(
     *,
     cause: FunctionType,
     expectsabbr: bool,
-    optdict: dict,
+    optdict: dict[Any, Any],
     **kwargs: Any,
 ) -> Option:
     if parse_islong(arg, **kwargs):

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/_processing/pulling.py

@@ -1,5 +1,6 @@
 import sys
-from typing import *
+from collections.abc import Iterable
+from typing import Optional
 
 from preparse._items.Item import Item
 from preparse._items.Positional import Positional
@@ -7,9 +8,9 @@ from preparse._items.Positional import Positional
 __all__ = ["pull"]
 
 
-def pull(args: Optional[Iterable] = None) -> list[Item]:
+def pull(args: Optional[Iterable[object]] = None) -> list[Item]:
     "This method acquires args."
-    argiter: Iterable
+    argiter: Iterable[object]
     if args is None:
         argiter = sys.argv[1:]
     else:

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/core/Optdict.py

@@ -1,9 +1,9 @@
-from typing import *
+from typing import Any, Optional, Self
 
 import cmp3  # type: ignore
 import datahold
 import setdoc
-from datarepr import datarepr
+from datarepr import datarepr  # type: ignore
 from frozendict import frozendict
 
 from preparse.core.enums import *
@@ -26,6 +26,10 @@ class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
 
     __format__ = object.__format__
 
+    @setdoc.basic
+    def __init__(self: Self, data: Any = (), /) -> None:
+        datahold.HoldDict[str, Nargs].__init__(self, data)
+
     @setdoc.basic
     def __repr__(self: Self, /) -> str:
         return datarepr(type(self).__name__, dict(self._data))
@@ -38,10 +42,10 @@ class Optdict(cmp3.CmpABC, datahold.HoldDict[str, Nargs]):
 
     @data.setter
     def data(self: Self, value: Any) -> None:
-        a: frozendict
+        a: frozendict[Any, Any]
         x: map
         y: map
         a = frozendict(value)
         x = map(str, a.keys())
         y = map(Nargs, a.values())
-        self._data = frozendict[str, Nargs](zip(x, y, strict=True))
+        self._data = frozendict(zip(x, y, strict=True))

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/core/PreParser.py

@@ -3,19 +3,20 @@ from __future__ import annotations
 import os
 import sys
 import types
-from typing import *
+from collections.abc import Iterable
+from typing import Any, Callable, Optional, Self, cast
 
 import click as cl
 import setdoc
 from copyable import Copyable
-from datarepr import datarepr
-from tofunc import tofunc
+from datarepr import datarepr  # type: ignore[attr-defined]
+from tofunc import tofunc  # type: ignore[attr-defined]
 
 from preparse._processing import *
 from preparse._utils.dataprop import dataprop
 from preparse.core.Click import Click
 from preparse.core.enums import *
-from preparse.core.Optdict import *
+from preparse.core.Optdict import Optdict
 from preparse.core.warnings import *
 
 __all__ = ["PreParser"]
@@ -39,9 +40,10 @@ class PreParser(Copyable):
         prog: Any = None,
         reconcilesorders: Any = True,
         special: Any = Tuning.MAINTAIN,
-        warn: Callable = str,
+        warn: Callable = str,  # type: ignore[type-arg]
     ) -> None:
-        self._data: dict[str, Any] = dict()
+        self._data: dict[str, Any]
+        self._data = dict()
         self.allowslong = allowslong
         self.allowsshort = allowsshort
         self.bundling = bundling
@@ -103,11 +105,11 @@ class PreParser(Copyable):
         dataA = Optdict(value)
         self._data["optdict"].clear()
         self._data["optdict"].update(dataA)
-        return self._data["optdict"]
+        return cast(Optdict, self._data["optdict"])
 
     def parse_args(
         self: Self,
-        args: Optional[Iterable] = None,
+        args: Optional[Iterable[object]] = None,
     ) -> list[str]:
         "This method parses args."
         return process(args, **self.todict())
@@ -154,9 +156,9 @@ class PreParser(Copyable):
         "This Tuning property determines the approach towards the special argument."
         return Tuning(value)
 
-    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.1.2 → preparse-1.1.4}/src/preparse/tests/test_data_toml.py

@@ -35,7 +35,7 @@ class TestDataToml(unittest.TestCase):
     def test_0(self: Self) -> None:
         data: dict[str, Any]
         name: str
-        kwargs: dict
+        kwargs: dict[str, Any]
         data = Utils.utils.get_data()
         for name, kwargs in data.items():
             with self.subTest(msg=name, **kwargs):
@@ -49,12 +49,12 @@ class TestDataToml(unittest.TestCase):
         warnings: Any,
         **kwargs: Any,
     ) -> None:
-        answer: list
-        capture: list
-        data: dict
-        erranswer: list
+        answer: list[Any]
+        capture: list[Any]
+        data: dict[str, Any]
+        erranswer: list[Any]
         msg: str
-        superanswer: list
+        superanswer: list[Any]
         parser: PreParser
         capture = list()
 
@@ -77,7 +77,11 @@ class TestDataToml(unittest.TestCase):
             superanswer,
         )
         self.assertEqual(answer, superanswer, msg=msg)
-        msg = "\n\ndata=%s,\nanswer=%s,\nsolution=%s,\n\n" % (data, answer, solution)
+        msg = "\n\ndata=%s,\nanswer=%s,\nsolution=%s,\n\n" % (
+            data,
+            answer,
+            solution,
+        )
         self.assertEqual(answer, solution, msg=msg)
         if not Utils.utils.istestable(warnings):
             return

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/tests/test_enums.py

@@ -1,5 +1,5 @@
 import unittest
-from typing import *
+from typing import Self
 
 from preparse.core.enums import *
 

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/tests/test_expit_toml.py

@@ -3,7 +3,7 @@ import math
 import tomllib
 import unittest
 from importlib import resources
-from typing import *
+from typing import Any, Self
 
 from click.testing import CliRunner
 
@@ -17,8 +17,8 @@ class Utils(enum.Enum):
     utils = None
 
     @staticmethod
-    def get_data() -> dict:
-        data: dict
+    def get_data() -> dict[Any, Any]:
+        data: dict[Any, Any]
         text: str
         text = resources.read_text("preparse.tests", "expit.toml")
         data = tomllib.loads(text)
@@ -45,7 +45,7 @@ class TestMainFunction(unittest.TestCase):
         stdout: Any,
         stderr: Any,
     ) -> None:
-        extra: dict
+        extra: dict[Any, Any]
         result: Any
         runner: CliRunner
         runner = CliRunner()
@@ -65,8 +65,8 @@ class TestMainFunction(unittest.TestCase):
             self.assertEqual(stderr, result.stderr)
 
     def test_0(self: Self) -> None:
-        data: dict
-        kwargs: dict
+        data: dict[Any, Any]
+        kwargs: dict[Any, Any]
         name: str
         data = Utils.utils.get_data()
         for name, kwargs in data.items():

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/tests/test_optdict.py

@@ -1,5 +1,5 @@
 import unittest
-from typing import *
+from typing import Self
 
 from preparse.core.enums import *
 from preparse.core.Optdict import Optdict

{preparse-1.1.2 → preparse-1.1.4}/src/preparse/tests/test_preparser.py

@@ -1,5 +1,5 @@
 import unittest
-from typing import *
+from typing import Any, Self
 
 from preparse.core.Click import Click
 from preparse.core.enums import *
@@ -29,7 +29,7 @@ class TestPreParser(unittest.TestCase):
         self.assertEqual(parser.optdict, parser_copy.optdict)
 
     def test_preparser_todict(self: Self) -> None:
-        expected_keys: list
+        expected_keys: list[Any]
         parser: PreParser
         result: Any
         parser = PreParser()

{preparse-1.1.2 → preparse-1.1.4}/src/preparse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: preparse
-Version: 1.1.2
+Version: 1.1.4
 Summary: This project preparses args for further parsing later on.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT
@@ -21,10 +21,10 @@ License-File: LICENSE.txt
 Requires-Dist: click<9,>=8.2
 Requires-Dist: cmp3<2,>=1.0
 Requires-Dist: copyable<2,>=1.1
-Requires-Dist: datahold<4,>=3.0
+Requires-Dist: datahold<4,>=3.0.34.dev1
 Requires-Dist: datarepr<2,>=1.2
 Requires-Dist: frozendict<3,>=2.4.7
-Requires-Dist: setdoc<2,>=1.2.20
+Requires-Dist: setdoc<2,>=1.3
 Requires-Dist: tofunc<2,>=1.1
 Dynamic: license-file
 

{preparse-1.1.2 → preparse-1.1.4}/src/preparse.egg-info/requires.txt

@@ -1,8 +1,8 @@
 click<9,>=8.2
 cmp3<2,>=1.0
 copyable<2,>=1.1
-datahold<4,>=3.0
+datahold<4,>=3.0.34.dev1
 datarepr<2,>=1.2
 frozendict<3,>=2.4.7
-setdoc<2,>=1.2.20
+setdoc<2,>=1.3
 tofunc<2,>=1.1