cmdchopper 0.1.0__tar.gz

cmdchopper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 0x4D2
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cmdchopper-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: cmdchopper
+Version: 0.1.0
+Summary: A simple yet powerful command string parser
+Author-email: 0x4D2 <1706119930@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/0x4D25F2/cmdchopper
+Project-URL: Issues, https://github.com/0x4D25F2/cmdchopper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

cmdchopper-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cmdchopper"
+version = "0.1.0"
+description = "A simple yet powerful command string parser"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "0x4D2", email = "1706119930@qq.com"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/0x4D25F2/cmdchopper"
+Issues = "https://github.com/0x4D25F2/cmdchopper/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["cmdchopper"]

cmdchopper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cmdchopper-0.1.0/src/cmdchopper/parser.py

@@ -0,0 +1,257 @@
+# pip install cmdchopper
+# Default type: str
+# Arg[name(,type,checker,default)](.blocked())
+# Arg["a3"]["*args"] #wildcard: list
+# Arg["a4"]["#text"] #wildcard: str
+# Checker(checker_function,failed_message)
+
+SUCCESS = 1
+INPUT_FAILED = -1
+ARG_FAILED = 0
+CHECKER_FAILED = -2
+
+
+class Checker:
+    def __init__(self, func, msg):
+        self.func = func
+        self.msg = msg
+
+
+no_checker = Checker(lambda x: True, "[你不应该看到这条消息...]")
+
+
+def minn(n):
+    return Checker(lambda x: x >= n, "必须大于{}".format(n))
+
+
+def maxn(n):
+    return Checker(lambda x: x <= n, "必须小于{}".format(n))
+
+
+def among(a, b):
+    return Checker(lambda x: a <= x <= b, "必须在{}和{}直接".format(a, b))
+
+
+def enum(*l):
+    return Checker(lambda x: x in l, "必须是以下值之一: " + ", ".join(l))
+
+
+class Wildcard: pass
+
+
+class ArgClass:
+    def __init__(self, default: bool, wildcard: int, args=None):
+        self.args = args.copy() if args else []
+        self.default = default
+        self.wildcard = wildcard
+        self.block = False
+    
+    def blocked(self):
+        self.block = True
+        return self
+    
+    def _clone(self):
+        return ArgClass(self.default, self.wildcard, self.args)
+    
+    def __getitem__(self, arg_spec):
+        if arg_spec is None:
+            return self
+        if not isinstance(arg_spec, tuple):
+            arg_spec = (arg_spec, str, None)
+        if len(arg_spec) > 4:
+            raise SyntaxError("too many arguments")
+        if not isinstance(arg_spec[0], str):
+            raise SyntaxError("arg_name must be a string")
+        if not arg_spec[0]:
+            raise SyntaxError("arg_name is empty")
+        if not isinstance(arg_spec[1], type):
+            raise SyntaxError("arg_type must be a type")
+        if len(arg_spec) == 4 and not isinstance(arg_spec[3], arg_spec[1]):
+            raise SyntaxError("default value is not paired with arg_type")
+        if len(arg_spec) <= 2 or arg_spec[2] is None:
+            if len(arg_spec) <= 3:
+                arg_spec = (arg_spec[0], arg_spec[1], no_checker)
+            else:
+                arg_spec = (arg_spec[0], arg_spec[1], no_checker, arg_spec[3])
+        if arg_spec[0][0] in ("*", "#"):
+            if self.wildcard == 0:
+                if arg_spec[0][0] == "*":
+                    self.wildcard = 1
+                elif arg_spec[0][0] == "#":
+                    self.wildcard = 2
+                if len(arg_spec) == 4:
+                    raise SyntaxError("no default value for wildcard arg")
+                arg_spec = list(arg_spec)
+                if arg_spec[0] != "*" and arg_spec[0] != "#":
+                    arg_spec[0] = arg_spec[0][1:]
+                if self.wildcard == 1:
+                    arg_spec[1] = list
+                else:
+                    arg_spec[1] = str
+                arg_spec = tuple(arg_spec)
+            else:
+                raise SyntaxError("too many wildcard arg")
+        elif self.wildcard:
+            raise SyntaxError("wildcard must be the last argument")
+        if len(arg_spec) == 4:
+            self.default = True
+        elif self.default and not self.wildcard:
+            raise SyntaxError("non-default argument follows default argument")
+        new = self._clone()
+        new.args.append(arg_spec)
+        return new
+    
+    def __repr__(self):
+        output = "Args"
+        for i in self.args:
+            if len(i) == 4:
+                output += f"[{i[0]}: {i[1].__name__} = {i[3]}]"
+            else:
+                output += f"[{i[0]}: {i[1].__name__}]"
+        return output
+
+
+class ArgInput:
+    def __getitem__(self, arg):
+        a = ArgClass(False, 0)
+        return a[arg]
+
+
+class ArgResult:
+    def __init__(self, kwargs, names):
+        self.arg_name = [i[0] for i in names]
+        for i in kwargs:
+            setattr(self, i, kwargs[i])
+    
+    def __getitem__(self, index):
+        if isinstance(index, int):
+            index = self.arg_name[index]
+        if isinstance(index, str):
+            return getattr(self, index)
+        raise TypeError()
+    
+    def __repr__(self):
+        arg_txt = []
+        for i in self.arg_name:
+            arg_txt.append(i + "=" + repr(self[i]))
+        return "ArgResult({})".format(", ".join(arg_txt))
+
+
+Arg = ArgInput()
+
+
+def arg_split(text, prefixes=None, quote_str=True, max_arg=None):
+    if isinstance(prefixes, str):
+        prefixes = [prefixes]
+    arg_list = [""]
+    mode_str = False
+    mode_escape = False
+    if prefixes:
+        pc = False
+        text += " "
+        for i in prefixes:  # Remove prefix
+            if text.startswith(i + " "):
+                if text.rstrip() == i.rstrip():
+                    return True, []
+                text = text[len(i):].lstrip()
+                pc = True
+                break
+        if not pc:
+            return False, "未找到匹配的前缀"
+    text = " " + text.rstrip() + " "
+    for i in range(1, len(text) - 1):
+        if max_arg and len(arg_list) == max_arg:
+            arg_list[-1] += text[i:].strip()
+            break
+        if mode_escape:
+            arg_list[-1] += text[i]
+            mode_escape = False
+            continue
+        elif text[i] == "\\":
+            mode_escape = True
+            continue
+        if mode_str:
+            if text[i] == "\"":
+                if text[i + 1] != " ":
+                    return False, "字符串参数后缺失空格"
+                mode_str = False
+            else:
+                arg_list[-1] += text[i]
+        else:
+            if quote_str and text[i] == "\"":
+                if text[i - 1] != " ":
+                    return False, "引号前必须为空格"
+                mode_str = True
+            elif text[i] == " ":
+                if text[i - 1] != " ":
+                    arg_list.append("")
+            else:
+                arg_list[-1] += text[i]
+    if mode_str:
+        return False, "字符串引号未闭合"
+    return True, arg_list
+
+
+class CommandParser:
+    def __init__(self, args, prefixes=None, quote_str=True):
+        self.args = args
+        self.prefixes = prefixes
+        self.quote_str = quote_str
+    
+    def _parse_single(self, output, args):
+        arg_list = {}
+        wc = args.wildcard == 1
+        args = args.args
+        arg_len = len(args)
+        if wc:
+            arg_len -= 1
+            i = -1
+        elif len(args) < len(output):
+            return ARG_FAILED, "提供了过多的参数"
+        for i in range(arg_len):
+            if i >= len(output):
+                if len(args[i]) == 4:
+                    arg_list[args[i][0]] = args[i][3]
+                else:
+                    return ARG_FAILED, "缺失参数：" + args[i][0]
+            else:
+                try:
+                    output[i] = args[i][1](output[i])
+                except ValueError:
+                    return ARG_FAILED, "{} 必须为 {} 类型，而非 {}".format(
+                        args[i][0], args[i][1].__name__, type(output[i]).__name__)
+                if not args[i][2].func(output[i]):
+                    return CHECKER_FAILED, args[i][0] + " " + args[i][2].msg
+                arg_list[args[i][0]] = output[i]
+        if wc:
+            arg_list[args[-1][0]] = output[i + 1:]
+        res = ArgResult(arg_list, args)
+        return SUCCESS, res
+    
+    def parse(self, text):
+        single_arg = isinstance(self.args, ArgClass)
+        success, output = arg_split(text, self.prefixes, self.quote_str)
+        if not success:
+            if single_arg:
+                return INPUT_FAILED, output
+            else:
+                return INPUT_FAILED, output, -1
+        if single_arg:
+            if self.args.wildcard == 2:
+                _, output = arg_split(text, self.prefixes, self.quote_str,
+                                      len(self.args.args))
+            success, result = self._parse_single(output, self.args)
+            return success, result
+        else:
+            result = None
+            for i in range(len(self.args)):
+                if self.args[i].wildcard == 2:
+                    _, output = arg_split(text, self.prefixes, self.quote_str,
+                                          len(self.args[i].args))
+                success, result = self._parse_single(output, self.args[i])
+                if success == SUCCESS:
+                    return success, result, i
+                elif success == CHECKER_FAILED and self.args[i].block:
+                    return success, result, -1
+            return success, result, -1
+

cmdchopper-0.1.0/src/cmdchopper.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: cmdchopper
+Version: 0.1.0
+Summary: A simple yet powerful command string parser
+Author-email: 0x4D2 <1706119930@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/0x4D25F2/cmdchopper
+Project-URL: Issues, https://github.com/0x4D25F2/cmdchopper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

cmdchopper-0.1.0/src/cmdchopper.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/cmdchopper/__init__.py
+src/cmdchopper/parser.py
+src/cmdchopper.egg-info/PKG-INFO
+src/cmdchopper.egg-info/SOURCES.txt
+src/cmdchopper.egg-info/dependency_links.txt
+src/cmdchopper.egg-info/top_level.txt

cmdchopper-0.1.0/src/cmdchopper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cmdchopper-0.1.0/src/cmdchopper.egg-info/top_level.txt

@@ -0,0 +1 @@
+cmdchopper