💥 MultiVar -> Field.multiple

Author: RF-Tar-Railt

src/arclet/alconna/__init__.py

@@ -38,9 +38,6 @@
 from .manager import ShortcutArgs as ShortcutArgs
 from .manager import command_manager as command_manager
 from .typing import AllParam as AllParam
-from .typing import MultiVar as MultiVar
-from .typing import Nargs as Nargs
-from .typing import StrMulti as StrMulti
 
 __version__ = "1.8.31"
 

src/arclet/alconna/args.py

@@ -4,15 +4,15 @@
 import dataclasses as dc
 import re
 import typing
-from typing import Any, Callable, Generic, TypeVar, ClassVar, ForwardRef, Final, TYPE_CHECKING
+from typing import Any, Callable, Generic, Literal, TypeVar, ClassVar, ForwardRef, Final, TYPE_CHECKING, get_origin, get_args
 from typing_extensions import dataclass_transform, ParamSpec, Concatenate, TypeAlias
 
-from nepattern import NONE, BasePattern, RawStr, UnionPattern, parser
+from nepattern import NONE, BasePattern, RawStr, UnionPattern, parser, STRING
 from tarina import Empty, lang
 
 from ._dcls import safe_dcls_kw, safe_field_kw
 from .exceptions import InvalidArgs
-from .typing import MultiVar, TAValue, parent_frame_namespace, merge_cls_and_parent_ns
+from .typing import TAValue, parent_frame_namespace, merge_cls_and_parent_ns
 
 _T = TypeVar("_T")
 
@@ -40,6 +40,8 @@ class Field(Generic[_T]):
     optional: bool = dc.field(default=False, compare=False, hash=False)
     hidden: bool = dc.field(default=False, compare=False, hash=False)
     kw_only: bool = dc.field(default=False, compare=False, hash=False)
+    multiple: bool | int | Literal["+", "*", "str"] = dc.field(default=False, compare=False, hash=False)
+    kw_sep: str = dc.field(default="=", compare=False, hash=False)
 
     @property
     def display(self):
@@ -87,11 +89,13 @@ def arg_field(
     missing_tips: Callable[[], str] | None = None,
     notice: str | None = None,
     seps: str = " ",
+    multiple: bool | int | Literal["+", "*", "str"] = False,
     kw_only: bool = False,
+    kw_sep: str = "=",
     optional: bool = False,
     hidden: bool = False,
 ) -> "Any":
-    return Field(default, default_factory, alias, completion, unmatch_tips, missing_tips, notice, seps, optional, hidden, kw_only)
+    return Field(default, default_factory, alias, completion, unmatch_tips, missing_tips, notice, seps, optional, hidden, kw_only, multiple, kw_sep)
 
 
 @dc.dataclass(**safe_dcls_kw(init=False, eq=True, unsafe_hash=True, slots=True))
@@ -167,8 +171,8 @@ def __init__(self, args: list[Arg[Any]], origin: type[ArgsBase] | None = None):
         self.data = args
         self.normal: list[Arg[Any]] = []
         self.keyword_only: dict[str, Arg[Any]] = {}
-        self.vars_positional: list[tuple[MultiVar, Arg[Any]]] = []
-        self.vars_keyword: list[tuple[MultiVar, Arg[Any]]] = []
+        self.vars_positional: list[tuple[int | Literal["+", "*", "str"], Arg[Any]]] = []
+        self.vars_keyword: list[tuple[str, Arg[Any]]] = []
         self._visit = set()
         self.optional_count = 0
         self.__check_vars__()
@@ -189,17 +193,20 @@ def __check_vars__(self):
             if arg.name in self._visit:
                 continue
             self._visit.add(arg.name)
-            if isinstance(arg.type_, MultiVar):
+            if arg.field.multiple is not False:
                 if arg.field.kw_only:
-                    # for slot in self.vars_positional:
-                    #     _, a = slot
-                    #     if arg.type_.base.sep in a.field.seps:
-                    #         raise InvalidArgs("varkey cannot use the same sep as varpos's Arg")
-                    self.vars_keyword.append((arg.type_, arg))
+                    for slot in self.vars_positional:
+                        _, a = slot
+                        if arg.field.kw_sep in a.field.seps:
+                            raise InvalidArgs("varkey cannot use the same sep as varpos's Arg")
+                    self.vars_keyword.append((arg.field.kw_sep, arg))
                 elif self.keyword_only:
                     raise InvalidArgs(lang.require("args", "exclude_mutable_args"))
                 else:
-                    self.vars_positional.append((arg.type_, arg))
+                    flag = arg.field.multiple
+                    if flag is True:
+                        flag = "+"
+                    self.vars_positional.append((flag, arg))
             elif arg.field.kw_only:
                 if self.vars_keyword:
                     raise InvalidArgs(lang.require("args", "exclude_mutable_args"))
@@ -328,6 +335,14 @@ def __new__(
                     field = Field(field)
                 if field.default is Empty and field.default_factory is Empty:
                     delattr(cls, name)
+            if field.multiple is not False:
+                if not field.kw_only:
+                    if get_origin(typ) is tuple:
+                        typ = get_args(typ)[0]
+                    elif field.multiple != "str" or typ is not str:
+                        raise TypeError(f"{name!r} is a varpos but does not have a tuple type annotation")
+                elif get_origin(typ) is not dict:
+                    raise TypeError(f"{name!r} is a varkey but does not have a dict type annotation")
             cls_args.append(Arg(name, typ, field))
         for name, value in cls.__dict__.items():
             if isinstance(value, Field) and name not in cls_annotations:

src/arclet/alconna/ingedia/_handlers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Any, Iterable
+from typing import TYPE_CHECKING, Any, Iterable, Literal
 
 from nepattern import ANY, STRING, AnyString, BasePattern
 from tarina import Empty, lang, safe_eval, split_once
@@ -19,7 +19,7 @@
     PauseTriggered,
     ParamsUnmatched,
 )
-from ..typing import KWBool, MultiVar, _AllParamPattern, _StrMulti
+from ..typing import KWBool, _AllParamPattern
 
 from ._util import levenshtein
 
@@ -74,12 +74,14 @@ def _validate(argv: Argv, target: Arg[Any], value: BasePattern[Any, Any, Any], r
     result[target.name] = res._value  # noqa
 
 
-def step_varpos(argv: Argv, args: _Args, slot: tuple[MultiVar, Arg], result: dict[str, Any]):
-    value, arg = slot
+def step_varpos(argv: Argv, args: _Args, slot: tuple[int | Literal["+", "*", "str"], Arg], result: dict[str, Any]):
+    flag, arg = slot
+    value = arg.type_
     key = arg.name
+    length = int(flag) if flag.__class__ is int else -1
     default_val = arg.field.default
     _result = []
-    kwonly_seps = "".join([arg.type_.sep for arg in args.keyword_only.values()])  # type: ignore
+    kwonly_seps = "".join([arg.field.kw_sep for arg in args.keyword_only.values()])
     count = 0
     while argv.current_index != argv.ndata:
         may_arg, _str = argv.next(arg.field.seps)
@@ -91,33 +93,36 @@ def step_varpos(argv: Argv, args: _Args, slot: tuple[MultiVar, Arg], result: dic
         if _str and kwonly_seps and split_once(pat.match(may_arg)["name"], kwonly_seps, argv.filter_crlf)[0] in args.keyword_only:  # noqa: E501  # type: ignore
             argv.rollback(may_arg)
             break
-        if _str and args.vars_keyword and "=" in may_arg: #args.vars_keyword[0][0].base.sep in may_arg:
+        if _str and args.vars_keyword and args.vars_keyword[0][0] in may_arg:
             argv.rollback(may_arg)
             break
-        if (res := value.base.validate(may_arg)).flag != "valid":
+        if (res := value.validate(may_arg)).flag != "valid":
             argv.rollback(may_arg)
             break
         _result.append(res._value)  # noqa
         count += 1
-        if 0 < value.length <= count:
+        if 0 < length <= count:
             break
     if not _result:
         if default_val is not Empty:
             _result = default_val if isinstance(default_val, Iterable) else ()
-        elif value.flag == "*":
+        elif flag == "*":
             _result = ()
         elif arg.field.optional:
             return
         else:
             raise ArgumentMissing(arg.field.get_missing_tips(lang.require("args", "missing").format(key=key)), arg)
-    if isinstance(value, _StrMulti):
+    if flag == "str":
         result[key] = arg.field.seps[0].join(_result)
     else:
         result[key] = tuple(_result)
 
 
-def step_varkey(argv: Argv, slot: tuple[MultiVar, Arg], result: dict[str, Any]):
-    value, arg = slot
+def step_varkey(argv: Argv, slot: tuple[str, Arg], result: dict[str, Any]):
+    kw_sep, arg = slot
+    flag = arg.field.multiple
+    length = int(flag) if flag.__class__ is int else -1
+    value = arg.type_
     name = arg.name
     default_val = arg.field.default
     _result = {}
@@ -129,23 +134,23 @@ def step_varkey(argv: Argv, slot: tuple[MultiVar, Arg], result: dict[str, Any]):
             break
         if _str and may_arg in global_config.remainders:
             break
-        if not (_kwarg := re.match(rf"^(-*[^{'='}]+){'='}(.*?)$", may_arg)):
+        if not (_kwarg := re.match(rf"^(-*[^{kw_sep}]+){kw_sep}(.*?)$", may_arg)):
             argv.rollback(may_arg)
             break
         key = _kwarg[1]
         if not (_m_arg := _kwarg[2]):
             _m_arg, _ = argv.next(arg.field.seps)
-        if (res := value.base.validate(_m_arg)).flag != "valid":
+        if (res := value.validate(_m_arg)).flag != "valid":
             argv.rollback(may_arg)
             break
         _result[key] = res._value  # noqa
         count += 1
-        if 0 < value.length <= count:
+        if 0 < length <= count:
             break
     if not _result:
         if default_val is not Empty:
             _result = default_val if isinstance(default_val, dict) else {}
-        elif value.flag == "*":
+        elif flag == "*":
             _result = {}
         elif arg.field.optional:
             return
@@ -158,8 +163,7 @@ def step_keyword(argv: Argv, args: _Args, result: dict[str, Any]):
     kwonly_seps = set()
     for arg in args.keyword_only.values():
         kwonly_seps.update(arg.field.seps)
-    # kwonly_seps1 = "".join([arg.type_.sep for arg in args.keyword_only.values()])  # type: ignore
-    kwonly_seps1 = "="
+    kwonly_seps1 = "".join([arg.field.kw_sep for arg in args.keyword_only.values()])
     target = len(args.keyword_only)
     count = 0
     while count < target:
@@ -181,7 +185,7 @@ def step_keyword(argv: Argv, args: _Args, result: dict[str, Any]):
             ):
                 break
             for arg in args.keyword_only.values():
-                if arg.type_.validate(may_arg).flag == "valid":  # type: ignore
+                if arg.type_.validate(may_arg).flag == "valid":
                     raise InvalidParam(lang.require("args", "key_missing").format(target=may_arg, key=arg.name), arg)
             for name in args.keyword_only:
                 if levenshtein(_key, name) >= argv.fuzzy_threshold:
@@ -193,7 +197,7 @@ def step_keyword(argv: Argv, args: _Args, result: dict[str, Any]):
             if isinstance(value, KWBool):
                 _m_arg = key
             else:
-                _m_arg, _ = argv.next("=")  # (args.keyword_only[_key].separators)
+                _m_arg, _ = argv.next(args.keyword_only[_key].separators)
         _validate(argv, arg, value, result, _m_arg, _str)
         count += 1
 

src/arclet/alconna/typing.py

@@ -103,58 +103,10 @@ def __calc_eq__(self, other):  # pragma: no cover
 AllParam: _AllParamPattern[Any] = _AllParamPattern()
 
 
-class MultiVar(BasePattern[T, Any, Literal[MatchMode.KEEP]]):
-    """对可变参数的包装"""
-
-    base: BasePattern[T, Any, Any]
-    flag: Literal["+", "*"]
-    length: int
-
-    def __init__(self, value: TAValue[T], flag: int | Literal["+", "*"] = "+"):
-        """构建一个可变参数
-
-        Args:
-            value (type | BasePattern): 参数的值
-            flag (int | Literal["+", "*"]): 参数的标记
-        """
-        self.base = value if isinstance(value, BasePattern) else parser(value)  # type: ignore
-        assert isinstance(self.base, BasePattern)
-        if not isinstance(flag, int):
-            alias = f"({self.base}{flag})"
-            self.flag = flag
-            self.length = -1
-        elif flag > 1:
-            alias = f"({self.base}+)[:{flag}]"
-            self.flag = "+"
-            self.length = flag
-        else:  # pragma: no cover
-            alias = str(self.base)
-            self.flag = "+"
-            self.length = 1
-        super().__init__(mode=MatchMode.KEEP, origin=self.base.origin, alias=alias)
-
-    def __repr__(self):
-        return self.alias
-
-
-Nargs = MultiVar
-
-
 class KWBool(BasePattern):
     """对布尔参数的包装"""
 
 
-class _StrMulti(MultiVar[str]):
-    pass
-
-
-StrMulti = _StrMulti(str)
-"""特殊参数, 用于匹配多个字符串, 并将结果通过 `str.join` 合并"""
-
-StrMulti.alias = "str+"
-StrMulti.refresh()
-
-
 def parent_frame_namespace(*, parent_depth: int = 2, force: bool = False) -> dict[str, Any] | None:
     """We allow use of items in parent namespace to get around the issue with `get_type_hints` only looking in the
     global module namespace. See https://github.com/pydantic/pydantic/issues/2678#issuecomment-1008139014 -> Scope

src/arclet/alconna/v1/__init__.py

@@ -39,9 +39,9 @@
 from arclet.alconna.typing import AllParam as AllParam  # noqa: F401
 # from arclet.alconna.typing import KeyWordVar as KeyWordVar  # noqa: F401
 # from arclet.alconna.typing import Kw as Kw  # noqa: F401
-from arclet.alconna.typing import MultiVar as MultiVar  # noqa: F401
-from arclet.alconna.typing import Nargs as Nargs  # noqa: F401
-from arclet.alconna.typing import StrMulti as StrMulti  # noqa: F401
+# from arclet.alconna.typing import MultiVar as MultiVar  # noqa: F401
+# from arclet.alconna.typing import Nargs as Nargs  # noqa: F401
+# from arclet.alconna.typing import StrMulti as StrMulti  # noqa: F401
 # from arclet.alconna.typing import UnpackVar as UnpackVar  # noqa: F401
 # from arclet.alconna.typing import Up as Up  # noqa: F401
 

tests/args_test.py

@@ -2,7 +2,7 @@
 
 from nepattern import INTEGER, BasePattern, MatchMode, combine
 
-from arclet.alconna import Args, Nargs, StrMulti
+from arclet.alconna import Args
 from devtool import analyse_args
 
 
@@ -55,19 +55,19 @@ def test_object():
 
 
 def test_multi():
-    arg8 = Args.multi(Nargs(str, "+"))
+    arg8 = Args.multi(str, multiple=True)
     assert analyse_args(arg8, ["a b c d"]).get("multi") == ("a", "b", "c", "d")
     assert analyse_args(arg8, [], raise_exception=False) != {"multi": ()}
-    arg8_1 = Args.kwargs(Nargs(str, "+"), kw_only=True)
+    arg8_1 = Args.kwargs(str, multiple=True, kw_only=True)
     assert analyse_args(arg8_1, ["a=b c=d"]).get("kwargs") == {"a": "b", "c": "d"}
-    arg8_2 = Args.multi(Nargs(int, "*"))
+    arg8_2 = Args.multi(int, multiple="*")
     assert analyse_args(arg8_2, ["1 2 3 4"]).get("multi") == (1, 2, 3, 4)
     assert analyse_args(arg8_2, []).get("multi") == ()
-    arg8_3 = Args.multi(Nargs(int, 3))
+    arg8_3 = Args.multi(int, multiple=3)
     assert analyse_args(arg8_3, ["1 2 3"]).get("multi") == (1, 2, 3)
     assert analyse_args(arg8_3, ["1 2"]).get("multi") == (1, 2)
     assert analyse_args(arg8_3, ["1 2 3 4"]).get("multi") == (1, 2, 3)
-    arg8_4 = Args.multi(Nargs(str, "*")).kwargs(Nargs(str, "*"), kw_only=True)
+    arg8_4 = Args.multi(str, multiple="*").kwargs(str, multiple="*", kw_only=True)
     assert analyse_args(arg8_4, ["1 2 3 4 a=b c=d"]).get("multi") == ("1", "2", "3", "4")
     assert analyse_args(arg8_4, ["1 2 3 4 a=b c=d"]).get("kwargs") == {
         "a": "b",
@@ -128,13 +128,12 @@ def test_kwonly():
         "width": 960,
         "height": 480,
     }
-    # FIXME: kw_sep
-    # arg14_2 = Args["foo", str]["bar", KeyWordVar(int, " ")]["baz", KeyWordVar(bool, ":")]
-    # assert analyse_args(arg14_2, ["abc baz:false -bar 123"]) == {
-    #     "bar": 123,
-    #     "baz": False,
-    #     "foo": "abc",
-    # }
+    arg14_2 = Args.foo(str).bar(int, kw_only=True, kw_sep=" ").baz(bool, kw_only=True, kw_sep=":")
+    assert analyse_args(arg14_2, ["abc baz:false -bar 123"]) == {
+        "bar": 123,
+        "baz": False,
+        "foo": "abc",
+    }
     arg14_3 = Args.foo(str).bar(int, kw_only=True).baz(bool, kw_only=True)
     assert analyse_args(arg14_3, ["abc baz=false bar=456"]) == {
         "bar": 456,
@@ -220,16 +219,14 @@ def test_annotated():
 
 
 def test_multi_multi():
-    from arclet.alconna.typing import MultiVar
-
-    arg20 = Args["foo", MultiVar(str)]["bar", MultiVar(int)]
+    arg20 = Args.foo(str, multiple=True).bar(int, multiple=True)
     assert analyse_args(arg20, ["a b -- 1 2"]) == {"foo": ("a", "b"), "bar": (1, 2)}
 
-    arg20_1 = Args["foo", MultiVar(int)]["bar", MultiVar(str)]
+    arg20_1 = Args.foo(int, multiple=True).bar(str, multiple=True)
     assert analyse_args(arg20_1, ["1 2 -- a b"]) == {"foo": (1, 2), "bar": ("a", "b")}
     assert analyse_args(arg20_1, ["1 2 a b"]) == {"foo": (1, 2), "bar": ("a", "b")}
 
-    arg20_2 = Args["foo", str]["bar", StrMulti]
+    arg20_2 = Args.foo(str).bar(str, multiple="str")
     assert analyse_args(arg20_2, ["a b"]) == {"foo": "a", "bar": "b"}
     assert analyse_args(arg20_2, ["a b c"]) == {"foo": "a", "bar": "b c"}