preparse 2.0.0.dev16__tar.gz → 2.0.0.dev18__tar.gz

preparse-2.0.0.dev18/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: preparse
+Version: 2.0.0.dev18
+Summary: This project preparses args for further parsing later on.
+Author-email: Johannes <johannes.programming@gmail.com>
+License-Expression: MIT
+Project-URL: Download, https://pypi.org/project/preparse/#files
+Project-URL: Index, https://pypi.org/project/preparse/
+Project-URL: Source, https://github.com/johannes-programming/preparse/
+Project-URL: Website, https://preparse.johannes-programming.online/
+Classifier: Development Status :: 3 - Alpha
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: click<9,>=8.2
+Requires-Dist: cmp3<2,>=1.0
+Requires-Dist: copyable<2,>=1.0
+Requires-Dist: datahold<4,>=3.1.dev3
+Requires-Dist: datarepr<2,>=1.1
+Requires-Dist: namings<2,>=1.0.dev0
+Requires-Dist: overloadable<2,>=1.1
+Requires-Dist: setdoc<2,>=1.2.20
+Requires-Dist: tofunc<2,>=1.0
+Dynamic: license-file
+
+========
+preparse
+========
+
+Each minor version has its own documentation.
+These docs can be found as rst-files in the ``docs/`` directory of this project.
+They can also be viewed on the website `https://preparse.johannes-programming.online/ <https://preparse.johannes-programming.online/>`_.

preparse-2.0.0.dev18/README.rst

@@ -0,0 +1,7 @@
+========
+preparse
+========
+
+Each minor version has its own documentation.
+These docs can be found as rst-files in the ``docs/`` directory of this project.
+They can also be viewed on the website `https://preparse.johannes-programming.online/ <https://preparse.johannes-programming.online/>`_.

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/pyproject.toml

@@ -1,7 +1,7 @@
 [build-system]
 build-backend = "setuptools.build_meta"
 requires = [
-    "setuptools>=64.0",
+    "setuptools>=77.0",
 ]
 
 [project]
@@ -10,34 +10,33 @@ authors = [
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
-    "License :: OSI Approved :: MIT License",
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Typing :: Typed",
 ]
 dependencies = [
     "click>=8.2,<9",
     "cmp3>=1.0,<2",
     "copyable>=1.0,<2",
-    "datahold>=3.0,<4",
+    "datahold>=3.1.dev3,<4",
     "datarepr>=1.1,<2",
-    "frozendict>=2.4.7,<3",
+    "namings>=1.0.dev0,<2",
     "overloadable>=1.1,<2",
-    "setdoc>=1.2.10,<2",
+    "setdoc>=1.2.20,<2",
     "tofunc>=1.0,<2",
 ]
 description = "This project preparses args for further parsing later on."
 keywords = []
+license = "MIT"
+license-files = [
+    "LICENSE.txt",
+]
 name = "preparse"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "2.0.0.dev16"
-
-[project.license]
-file = "LICENSE.txt"
+version = "2.0.0.dev18"
 
 [project.urls]
 Download = "https://pypi.org/project/preparse/#files"

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_items/Bundle.py

@@ -5,7 +5,7 @@ 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 *
+from preparse.enums.Nargs import Nargs
 
 __all__ = ["Bundle"]
 
@@ -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, chars: str) -> list[str]:
         ans: list[str]
         x: str
         ans = list()
@@ -73,12 +73,12 @@ class Bundle(Option):
         else:
             return ["-" + self.chars, self.right]
 
-    def split(self: Self, *, allowslong: bool) -> list[Item]:
+    def split(self: Self, *, allowsLong: bool) -> list[Item]:
         ans: list[Self]
         parts: list[str]
         x: str
-        if allowslong:
-            parts = self._split_allowslong(self.chars)
+        if allowsLong:
+            parts = self._split_allowsLong(self.chars)
         else:
             parts = self._split_shortonly(self.chars)
         ans = list()

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_items/Item.py

@@ -1,11 +1,10 @@
 import abc
 from typing import *
 
+import namings
 import setdoc
 from copyable import Copyable
 
-from preparse.core.enums import *
-
 __all__ = ["Item"]
 
 
@@ -14,7 +13,7 @@ class Item(Copyable):
 
     @setdoc.basic
     def copy(self: Self) -> Self:
-        return type(self)(**self.todict())
+        return type(self)(**self.toNaming())
 
     @abc.abstractmethod
     def deparse(self: Self) -> list[str]: ...
@@ -23,14 +22,14 @@ class Item(Copyable):
     @abc.abstractmethod
     def sortkey(cls: type) -> int: ...
 
-    def todict(self: Self) -> dict:
+    def toNaming(self: Self) -> namings.Naming:
         "This method returns a dict representing the current instance."
-        ans: dict
+        ans: namings.Naming
         try:
             ans = self._data
         except AttributeError:
-            self._data = dict()
-            ans = dict()
+            self._data = namings.Naming()
+            ans = namings.Naming()
         else:
-            ans = dict(ans)
+            ans = namings.Naming(ans)
         return ans

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_items/Long.py

@@ -1,11 +1,10 @@
-import operator
 from typing import *
 
 import setdoc
 
 from preparse._items.Option import Option
 from preparse._utils.dataprop import dataprop
-from preparse.core.enums import *
+from preparse.enums.Nargs import Nargs
 
 __all__ = ["Long"]
 
@@ -13,7 +12,6 @@ __all__ = ["Long"]
 class Long(Option):
 
     abbr: str
-    abbrlen: Optional[int]
     fullkey: str
     joined: bool
     nargs: Nargs
@@ -26,31 +24,20 @@ class Long(Option):
         self: Self,
         *,
         fullkey: str,
-        abbrlen: Optional[int] = None,
         joined: bool | str = False,
         right: Optional[str] = None,
     ) -> None:
         self.fullkey = fullkey
-        self.abbrlen = abbrlen
         self.joined = joined
         self.right = right
 
-    @property
-    def abbr(self: Self) -> str:
-        return self.fullkey[: self.abbrlen]
-
-    @dataprop
-    def abbrlen(self: Self, x: Optional[SupportsIndex]) -> Optional[int]:
-        if x is not None:
-            return operator.index(x)
-
     def deparse(self: Self) -> list[str]:
         if self.right is None:
-            return [self.abbr]
+            return [self.fullkey]
         elif self.joined:
-            return [self.abbr + "=" + self.right]
+            return [self.fullkey + "=" + self.right]
         else:
-            return [self.abbr, self.right]
+            return [self.fullkey, self.right]
 
     @dataprop
     def fullkey(self: Self, x: Any) -> str:

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_items/Option.py

@@ -3,7 +3,7 @@ from typing import *
 
 from preparse._items.Item import Item
 from preparse._utils.dataprop import dataprop
-from preparse.core.enums import *
+from preparse.enums.Nargs import Nargs
 
 __all__ = ["Option"]
 

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_items/Positional.py

@@ -4,7 +4,6 @@ import setdoc
 
 from preparse._items.Item import Item
 from preparse._utils.dataprop import dataprop
-from preparse.core.enums import *
 
 __all__ = ["Positional"]
 

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_items/Special.py

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

preparse-2.0.0.dev18/src/preparse/_processing/__init__.py

@@ -0,0 +1,51 @@
+from types import FunctionType
+from typing import *
+
+import datahold
+
+from preparse._items import Item
+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.enums.Tuning import Tuning
+
+__all__ = ["process"]
+
+
+def process(
+    args: Optional[Iterable] = None,
+    *,
+    abbr: Optional[Tuning],
+    allowsLong: bool,
+    allowsShort: bool,
+    bundling: Tuning,
+    expectsPOSIX: bool,
+    optNaming: datahold.DataNaming,
+    prog: str,
+    reconcilesOrders: bool,
+    special: Tuning,
+    warn: FunctionType,
+) -> list[str]:
+    "This method parses args."
+    items: list[Item]
+    items = pull(args)
+    items = parse(
+        items,
+        abbr=abbr,
+        allowsLong=allowsLong,
+        allowsShort=allowsShort,
+        expectsPOSIX=expectsPOSIX,
+        optNaming=optNaming,
+        prog=prog,
+        warn=warn,
+    )
+    items = digest(
+        items,
+        allowsLong=allowsLong,
+        bundling=bundling,
+        expectsPOSIX=expectsPOSIX,
+        reconcilesOrders=reconcilesOrders,
+        special=special,
+    )
+    return deparse(items)

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_processing/digesting.py

@@ -5,8 +5,7 @@ from preparse._items.Item import Item
 from preparse._items.Option import Option
 from preparse._items.Positional import Positional
 from preparse._items.Special import Special
-from preparse.core.enums import *
-from preparse.core.warnings import *
+from preparse.enums.Tuning import Tuning
 
 __all__ = ["digest"]
 
@@ -14,10 +13,10 @@ __all__ = ["digest"]
 def digest(
     items: list[Item],
     *,
-    allowslong: bool,
+    allowsLong: bool,
     bundling: Tuning,
-    expectsposix: bool,
-    reconcilesorders: bool,
+    expectsPOSIX: bool,
+    reconcilesOrders: bool,
     special: Tuning,
 ) -> list[Item]:
     ans: list[Item]
@@ -25,19 +24,19 @@ def digest(
 
     ans = digest_special(
         ans,
-        expectsposix=expectsposix,
-        reconcilesorders=reconcilesorders,
+        expectsPOSIX=expectsPOSIX,
+        reconcilesOrders=reconcilesOrders,
         special=special,
     )
     ans = digest_order(
         ans,
-        expectsposix=expectsposix,
-        reconcilesorders=reconcilesorders,
+        expectsPOSIX=expectsPOSIX,
+        reconcilesOrders=reconcilesOrders,
     )
     ans = digest_bundling(
         ans,
         bundling=bundling,
-        allowslong=allowslong,
+        allowsLong=allowsLong,
     )
     return ans
 
@@ -45,11 +44,11 @@ def digest(
 def digest_bundling(
     items: list[Item],
     *,
-    allowslong: bool,
+    allowsLong: bool,
     bundling: Tuning,
 ) -> list[Item]:
     if bundling == Tuning.MINIMIZE:
-        return digest_bundling_min(items, allowslong=allowslong)
+        return digest_bundling_min(items, allowsLong=allowsLong)
     if bundling == Tuning.MAXIMIZE:
         return digest_bundling_max(items)
     return items
@@ -58,14 +57,14 @@ def digest_bundling(
 def digest_bundling_min(
     items: list[Item],
     *,
-    allowslong: bool,
+    allowsLong: bool,
 ) -> list[Item]:
     ans: list[Item]
     item: Item
     ans = list()
     for item in items:
         if isinstance(item, Bundle):
-            ans += item.split(allowslong=allowslong)
+            ans += item.split(allowsLong=allowsLong)
         else:
             ans.append(item)
     return ans
@@ -96,16 +95,16 @@ def digest_bundling_max(items: list[Item]) -> list[Item]:
 def digest_order(
     items: list[Item],
     *,
-    expectsposix: bool,
-    reconcilesorders: bool,
+    expectsPOSIX: bool,
+    reconcilesOrders: bool,
 ) -> list[Item]:
     ans: list[Item]
     comp: bool
     index: int
     ans = list(items)
-    if not reconcilesorders:
+    if not reconcilesOrders:
         return ans
-    if not expectsposix:
+    if not expectsPOSIX:
         ans.sort(key=digest_order_key)
         return ans
     index = len(ans)
@@ -167,8 +166,8 @@ def digest_special_max(items: list[Item]) -> list[Item]:
 def digest_special_min(
     items: list[Item],
     *,
-    expectsposix: bool,
-    reconcilesorders: bool,
+    expectsPOSIX: bool,
+    reconcilesOrders: bool,
 ) -> list[Item]:
     ans: list[Item]
     index: int
@@ -176,7 +175,7 @@ def digest_special_min(
     isposix: bool
     ans = list(items)
     isdel = True
-    isposix = expectsposix and not reconcilesorders
+    isposix = expectsPOSIX and not reconcilesOrders
     index = len(items)
     while True:
         index -= 1

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_processing/parsing.py

@@ -1,22 +1,23 @@
 from types import FunctionType
 from typing import *
 
+import datahold
+
 from preparse._items.Bundle import Bundle
 from preparse._items.Item import Item
 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 *
+from preparse.enums.Nargs import Nargs
+from preparse.enums.Tuning import Tuning
+from preparse.warners.AmbiguousOptionWarner import AmbiguousOptionWarner as PAOW
+from preparse.warners.InvalidOptionWarner import InvalidOptionWarner as PIOW
+from preparse.warners.RequiredArgumentWarner import RequiredArgumentWarner as PRAW
+from preparse.warners.UnallowedArgumentWarner import UnallowedArgumentWarner as PUAW
 
 __all__ = ["parse"]
 
-PAOW = warnings.PreparseAmbiguousOptionWarning
-PIOW = warnings.PreparseInvalidOptionWarning
-PUAW = warnings.PreparseUnallowedArgumentWarning
-PRAW = warnings.PreparseRequiredArgumentWarning
-
 
 def parse(
     args: list[str],
@@ -29,7 +30,7 @@ def parse_bundling(
     arg: str,
     *,
     cause: FunctionType,
-    optdict: dict,
+    optNaming: datahold.DataNaming,
 ) -> Bundle:
     ans: Bundle
     x: int
@@ -40,7 +41,7 @@ def parse_bundling(
             continue
         ans.chars += y
         try:
-            ans.nargs = optdict["-" + y]
+            ans.nargs = optNaming["-" + y]
         except KeyError:
             cause(PIOW, option=y, islong=False)
             ans.nargs = Nargs.NO_ARGUMENT
@@ -68,10 +69,10 @@ def parse_generator(
     items: list[Positional],
     *,
     abbr: Optional[Tuning],
-    allowslong: bool,
-    allowsshort: bool,
-    expectsposix: bool,
-    optdict: dict,
+    allowsLong: bool,
+    allowsShort: bool,
+    expectsPOSIX: bool,
+    optNaming: datahold.DataNaming,
     prog: str,
     warn: FunctionType,
 ) -> Generator[Any, Any, Any]:
@@ -79,7 +80,7 @@ def parse_generator(
     cause: FunctionType
     last: Optional[Option]
     item: Positional
-    broken = not (allowslong or allowsshort)
+    broken = not (allowsLong or allowsShort)
     cause = parse_cause(prog=prog, warn=warn)
     last = None
     for item in items:
@@ -101,15 +102,15 @@ def parse_generator(
         if item.isobvious():
             # if the item is positional
             yield item
-            broken = expectsposix
+            broken = expectsPOSIX
             continue
         last = parse_option(
             item.value,
             abbr=abbr,
-            allowslong=allowslong,
-            allowsshort=allowsshort,
+            allowsLong=allowsLong,
+            allowsShort=allowsShort,
             cause=cause,
-            optdict=optdict,
+            optNaming=optNaming,
         )
         if not last.ishungry():
             yield last
@@ -128,24 +129,25 @@ def parse_long(
     arg: str,
     *,
     abbr: Optional[Tuning],
-    allowsshort: bool,
+    allowsShort: bool,
     cause: FunctionType,
-    optdict: dict,
+    optNaming: datahold.DataNaming,
 ) -> Long:
     ans: Long
+    fullkey_: str
+    minlen: int
     parts: list[str]
     parts = arg.split("=", 1)
     ans = Long(fullkey=parts.pop(0))
     if len(parts):
         ans.joined = True
         ans.right = parts.pop()
-    ans.abbrlen = len(ans.fullkey)
-    if ans.fullkey in optdict.keys():
+    if ans.fullkey in optNaming.keys():
         parts = [ans.fullkey]
-    elif abbr is not None:
-        parts = parse_long_startswith(ans.abbr, keys=optdict.keys())
+    elif abbr is None:
+        parts = []  # can be assumed
     else:
-        parts = list()  # can be assumed
+        parts = parse_long_startswith(ans.fullkey, keys=optNaming.keys())
     if len(parts) == 0:
         ans.nargs = Nargs.OPTIONAL_ARGUMENT
         cause(PIOW, option=arg, islong=True)
@@ -154,21 +156,22 @@ def parse_long(
         ans.nargs = Nargs.OPTIONAL_ARGUMENT
         cause(PAOW, option=arg, possibilities=parts)
         return ans
-    (ans.fullkey,) = parts
+    (fullkey_,) = parts
     if abbr == Tuning.MINIMIZE:
-        ans.abbrlen = len(ans.fullkey)
+        ans.fullkey = fullkey_
     if abbr == Tuning.MAXIMIZE:
-        parts = list(optdict.keys())
-        parts.remove(ans.fullkey)
-        ans.abbrlen = parse_minlen(
-            abbr=ans.abbr,
-            allowsshort=allowsshort,
+        parts = list(optNaming.keys())
+        parts.remove(fullkey_)
+        minlen = parse_minlen(
+            abbr=ans.fullkey,
+            allowsShort=allowsShort,
             joined=ans.joined,
             keys=tuple(parts),
         )
-    ans.nargs = optdict[ans.fullkey]
+        ans.fullkey = fullkey_[:minlen]
+    ans.nargs = optNaming[fullkey_]
     if (ans.nargs == Nargs.NO_ARGUMENT) and (ans.right is not None):
-        cause(PUAW, option=ans.fullkey)
+        cause(PUAW, option=fullkey_)
     return ans
 
 
@@ -189,13 +192,13 @@ def parse_long_startswith(
 def parse_minlen(
     *,
     abbr: str,
-    allowsshort: bool,
+    allowsShort: bool,
     joined: bool,
     keys: tuple[str, ...],
 ) -> int:
     m: int
     n: int
-    m = 2 + allowsshort - joined
+    m = 2 + allowsShort - joined
     n = len(abbr)
     while n >= m and not any(z.startswith(abbr[:n]) for z in keys):
         n -= 1
@@ -206,22 +209,22 @@ def parse_option(
     arg: str,
     *,
     abbr: Optional[Tuning],
-    allowslong: bool,
-    allowsshort: bool,
+    allowsLong: bool,
+    allowsShort: bool,
     cause: FunctionType,
-    optdict: dict,
+    optNaming: datahold.DataNaming,
 ) -> Option:
-    if (allowslong and arg.startswith("--")) or not allowsshort:
+    if (allowsLong and arg.startswith("--")) or not allowsShort:
         return parse_long(
             arg,
             abbr=abbr,
-            allowsshort=allowsshort,
+            allowsShort=allowsShort,
             cause=cause,
-            optdict=optdict,
+            optNaming=optNaming,
         )
     else:
         return parse_bundling(
             arg,
             cause=cause,
-            optdict=optdict,
+            optNaming=optNaming,
         )

{preparse-2.0.0.dev16 → preparse-2.0.0.dev18}/src/preparse/_utils/dataprop.py

@@ -1,5 +1,7 @@
 from typing import *
 
+import namings
+
 __all__ = ["dataprop"]
 
 
@@ -10,11 +12,11 @@ def dataprop(func: Callable) -> property:
         return self._data[func.__name__]
 
     def fset(self: Self, value: Any) -> None:
-        self._data = getattr(self, "_data", dict())
+        self._data = getattr(self, "_data", namings.Naming())
         self._data[func.__name__] = func(self, value)
 
-    kwargs: dict[str, Any]
-    kwargs = dict()
+    kwargs: namings.Naming
+    kwargs = namings.Naming()
     kwargs["doc"] = func.__doc__
     kwargs["fget"] = fget
     kwargs["fset"] = fset