c2e 1.dev10__tar.gz → 1.dev12__tar.gz

{c2e-1.dev10/src/c2e.egg-info → c2e-1.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2e
-Version: 1.dev10
+Version: 1.dev12
 Summary: C2E: Console Command Engine
 Author: iFamished
 License: GPL-3.0

{c2e-1.dev10 → c2e-1.dev12}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "c2e"
-version = "1-dev.10"
+version = "1-dev.12"
 description = "C2E: Console Command Engine"
 readme = "README.md"
 requires-python = ">=3.14"

c2e-1.dev12/src/c2e/dispatch.py

@@ -0,0 +1,182 @@
+from mapres import res
+from .dsl import COMMANDS, parse_line, help_command, help_child, help_arg
+
+
+def help_cmd_arg(cmd, meta):
+    lines = []
+    a = meta.name
+    lines.append(res(f'<bold><aqua>{a}<reset>: <gray>Retrieve and print the {a} of the server<reset>'))
+
+    u = res(f'<aqua>Usage:<reset> <gold>{cmd.name}<reset> <aqua>{a}<reset>')
+    req = []
+    opt = []
+
+    for pn in meta.params:
+        ps = cmd.params.get(pn)
+        t = ps.type_.__name__ if ps else 'str'
+        if pn in meta.required_params:
+            req.append(res(f'<dark_gray>\\<<reset>{pn}:{t}<dark_gray>\\><reset>'))
+        else:
+            opt.append(res(f'<dark_gray>[<reset>{pn}:{t}<dark_gray>]<reset>'))
+
+    if req:
+        u += ' ' + ' '.join(req)
+    if opt:
+        u += ' ' + ' '.join(opt)
+    if meta.flags:
+        u += res(' <dark_gray>[<reset>--flags<dark_gray>]<reset>')
+    lines.append(u)
+
+    if meta.params:
+        lines.append('')
+        lines.append(res('\0    <light_purple>Params:<reset>'))
+        for pn in meta.params:
+            ps = cmd.params.get(pn)
+            if not ps:
+                continue
+            t = ps.type_.__name__
+            d = ps.desc or 'No description'
+            lines.append(
+                res(f'\0        <blue>{pn}<reset> (type=<gold>{t}<reset>, default=<gray>{ps.default}<reset>): <gray>{d}<reset>')
+            )
+
+    if meta.flags:
+        lines.append('')
+        lines.append(res('\0    <light_purple>Flags:<reset>'))
+        for fn in meta.flags:
+            fs = cmd.flags.get(fn)
+            if not fs:
+                continue
+            d = fs.desc or 'No description'
+            lines.append(res(f'\0        <blue>--{fn}<reset>: <gray>{d}<reset>'))
+
+    return '\n'.join(lines)
+
+
+def dispatch(cli, line):
+    p = parse_line(line)
+    if not p.sub:
+        return
+
+    cmd = COMMANDS.get(p.sub)
+    if not cmd:
+        return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown command {p.sub}<reset>'))
+
+    # top-level help (no args)
+    if 'help' in p.flags and not p.pos:
+        return cli.safePrint(help_command(cmd))
+
+    # ------------------------------------------------------------
+    # CASE 1: command has children → existing child logic
+    # ------------------------------------------------------------
+    if cmd.children:
+        if not p.pos:
+            return cli.safePrint(res('<red>Error:<reset> <gray>Missing subcommand<reset>'))
+
+        cname = p.pos[0]
+        child = cmd.children.get(cname)
+        if not child:
+            return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown subcommand {cname}<reset>'))
+
+        if 'help' in p.flags and len(p.pos) == 1:
+            return cli.safePrint(help_child(child))
+
+        if 'help' in p.flags and len(p.pos) >= 2:
+            an = p.pos[1]
+            meta = child.args_meta.get(an)
+            if not meta:
+                return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown argument {an}<reset>'))
+            return cli.safePrint(help_arg(child, meta))
+
+        arg = p.pos[1] if len(p.pos) > 1 else None
+        if child.requires_arg and arg is None:
+            return cli.safePrint(
+                res(f'<red>Error:<reset> <gray>Subcommand {child.name} requires an argument<reset>')
+            )
+
+        g = child.func.__globals__
+
+        for n, ps in child.params.items():
+            if n in p.params:
+                try:
+                    v = ps.type_(p.params[n])
+                except Exception:
+                    v = ps.default
+            else:
+                v = ps.default
+
+            def wrap(f=ps.func, val=v):
+                def w():
+                    return f(val)
+                return w
+
+            g[n] = wrap()
+
+        for n, fs in child.flags.items():
+            present = n in p.flags
+
+            def wrap(f=fs.func, pr=present):
+                def w():
+                    return pr
+                return w
+
+            g[n] = wrap()
+
+        f = child.func
+        if f.__code__.co_argcount >= 2:
+            return f(cli, arg)
+        return f(cli)
+
+    # ------------------------------------------------------------
+    # CASE 2: command has NO children → treat like child
+    # ------------------------------------------------------------
+    arg = p.pos[0] if p.pos else None
+
+    # arg-level help for top-level commands
+    if 'help' in p.flags and arg is not None:
+        meta = cmd.args_meta.get(arg)
+        if not meta:
+            return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown argument {arg}<reset>'))
+        return cli.safePrint(help_cmd_arg(cmd, meta))
+
+    # command-level help (no arg)
+    if 'help' in p.flags and arg is None:
+        return cli.safePrint(help_command(cmd))
+
+    if cmd.requires_arg and arg is None:
+        return cli.safePrint(
+            res(f'<red>Error:<reset> <gray>Command {cmd.name} requires an argument<reset>')
+        )
+
+    g = cmd.func.__globals__
+
+    for n, ps in cmd.params.items():
+        if n in p.params:
+            try:
+                v = ps.type_(p.params[n])
+            except Exception:
+                v = ps.default
+        else:
+            v = ps.default
+
+        def wrap(f=ps.func, val=v):
+            def w():
+                return f(val)
+            return w
+
+        g[n] = wrap()
+
+    for n, fs in cmd.flags.items():
+        present = n in p.flags
+
+        def wrap(f=fs.func, pr=present):
+            def w():
+                return pr
+            return w
+
+        g[n] = wrap()
+
+    f = cmd.func
+    if f.__code__.co_argcount >= 2:
+        return f(cli, arg)
+    return f(cli)

{c2e-1.dev10 → c2e-1.dev12}/src/c2e/dsl.py

@@ -48,16 +48,10 @@ class BaseSpec:
         self._parse_args_meta()
         self._infer_arg_requirement()
 
-    # ------------------------------
-    # Docstring extraction
-    # ------------------------------
     def _doc(self, f):
         d = f.__doc__
         return d.strip().splitlines()[0].strip() if d else None
 
-    # ------------------------------
-    # __args__ block extraction
-    # ------------------------------
     def _extract_args_block(self):
         src = inspect.getsource(self.func)
         lines = src.splitlines()
@@ -81,9 +75,6 @@ class BaseSpec:
             raw = '\n'.join(l.strip() for l in block)
             setattr(self.func, '__args__', raw)
 
-    # ------------------------------
-    # Parse __args__ metadata
-    # ------------------------------
     def _parse_args_meta(self):
         raw = getattr(self.func, '__args__', None)
         if not raw:
@@ -125,9 +116,6 @@ class BaseSpec:
 
             self.args_meta[arg] = ArgMeta(arg, params, flags, req_p, req_f)
 
-    # ------------------------------
-    # Infer required/optional positional arg
-    # ------------------------------
     def _infer_arg_requirement(self):
         sig = inspect.signature(self.func)
         ps = list(sig.parameters.values())
@@ -147,9 +135,6 @@ class BaseSpec:
             self.requires_arg = False
             self.optional_arg = False
 
-    # ------------------------------
-    # Param decorator
-    # ------------------------------
     def param(self, name, type=str, default=None):
         def deco(f):
             py = name.replace('-', '_')
@@ -158,9 +143,6 @@ class BaseSpec:
             return f
         return deco
 
-    # ------------------------------
-    # Flag decorator
-    # ------------------------------
     def flag(self, name):
         def deco(f):
             py = name.replace('-', '_')
@@ -170,10 +152,6 @@ class BaseSpec:
         return deco
 
 
-# ------------------------------------------------------------
-# ChildSpec (inherits BaseSpec)
-# ------------------------------------------------------------
-
 class ChildSpec(BaseSpec):
     def __init__(self, parent, name, func):
         self.parent = parent
@@ -181,10 +159,6 @@ class ChildSpec(BaseSpec):
         super().__init__(func)
 
 
-# ------------------------------------------------------------
-# CommandSpec (inherits BaseSpec)
-# ------------------------------------------------------------
-
 class CommandSpec(BaseSpec):
     def __init__(self, name, func, namespace=False):
         self.name = name
@@ -201,10 +175,6 @@ class CommandSpec(BaseSpec):
         return deco
 
 
-# ------------------------------------------------------------
-# DSL entry point
-# ------------------------------------------------------------
-
 class CommandDSL:
     def __call__(self, name, namespace=False):
         def deco(f):
@@ -216,10 +186,6 @@ class CommandDSL:
 command = CommandDSL()
 
 
-# ------------------------------------------------------------
-# ParsedArgs structure
-# ------------------------------------------------------------
-
 @dataclass
 class ParsedArgs:
     sub: str | None
@@ -228,10 +194,6 @@ class ParsedArgs:
     params: dict[str, str]
 
 
-# ------------------------------------------------------------
-# Line parser
-# ------------------------------------------------------------
-
 def parse_line(raw):
     raw = raw.strip()
     if not raw:
@@ -255,15 +217,12 @@ def parse_line(raw):
     return ParsedArgs(sub, pos, flags, params)
 
 
-# ------------------------------------------------------------
-# Help generation (unchanged)
-# ------------------------------------------------------------
-
 def help_command(cmd):
     lines = []
     d = cmd.desc or 'No description'
     lines.append(res(f'<bold><yellow>{cmd.name}<reset>: <gray>{d}<reset>'))
 
+    # Usage
     if cmd.children:
         if cmd.is_namespace:
             u = res(f'<aqua>Usage:<reset> <gold>{cmd.name}<reset> <dark_gray>\\<<reset>child<dark_gray>\\><reset>')
@@ -271,12 +230,38 @@ def help_command(cmd):
             u = res(f'<aqua>Usage:<reset> <gold>{cmd.name}<reset> <dark_gray>[<reset>child<dark_gray>]<reset>')
     else:
         u = res(f'<aqua>Usage:<reset> <gold>{cmd.name}<reset>')
+        if cmd.args_meta:
+            u += res(' <dark_gray>\\<<reset>arg<dark_gray>\\><reset>')
+        if cmd.params:
+            u += res(' <dark_gray>[<reset>params<dark_gray>]<reset>')
+        if cmd.flags:
+            u += res(' <dark_gray>[<reset>--flags<dark_gray>]<reset>')
+    lines.append(u)
 
-    if cmd.flags:
-        u += res(' <dark_gray>[<reset>--flags<dark_gray>]<reset>')
+    # Args (for commands without children)
+    if cmd.args_meta:
+        lines.append('')
+        lines.append(res('\0    <light_purple>Args:<reset>'))
+        for a, m in cmd.args_meta.items():
+            parts = [res(f'<green>{a}<reset>')]
+            for pn in m.params:
+                parts.append(res(f'<dark_gray>[<reset>{pn}<dark_gray>]<reset>'))
+            for fn in m.flags:
+                parts.append(res(f'<dark_gray>[<reset>--{fn}<dark_gray>]<reset>'))
+            lines.append('\0        ' + ' '.join(parts))
 
-    lines.append(u)
+    # Params
+    if cmd.params:
+        lines.append('')
+        lines.append(res('\0    <light_purple>Params:<reset>'))
+        for n, ps in cmd.params.items():
+            t = ps.type_.__name__
+            d = ps.desc or 'No description'
+            lines.append(
+                res(f'\0        <blue>{n}<reset> (type=<gold>{t}<reset>, default=<gray>{ps.default}<reset>): <gray>{d}<reset>')
+            )
 
+    # Flags
     if cmd.flags:
         lines.append('')
         lines.append(res('\0    <light_purple>Flags:<reset>'))
@@ -284,6 +269,7 @@ def help_command(cmd):
             d = fs.desc or 'No description'
             lines.append(res(f'\0        <blue>--{fs.name}<reset>: <gray>{d}<reset>'))
 
+    # Children
     if cmd.children:
         lines.append('')
         lines.append(res('\0    <light_purple>Children:<reset>'))

{c2e-1.dev10 → c2e-1.dev12/src/c2e.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2e
-Version: 1.dev10
+Version: 1.dev12
 Summary: C2E: Console Command Engine
 Author: iFamished
 License: GPL-3.0

c2e-1.dev10/src/c2e/dispatch.py

@@ -1,72 +0,0 @@
-from mapres import res
-from .dsl import COMMANDS, parse_line, help_command, help_child, help_arg
-
-
-def dispatch(cli, line):
-    p = parse_line(line)
-    if not p.sub:
-        return
-
-    cmd = COMMANDS.get(p.sub)
-    if not cmd:
-        return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown command {p.sub}<reset>'))
-
-    if 'help' in p.flags and not p.pos:
-        return cli.safePrint(help_command(cmd))
-
-    if cmd.children:
-        if not p.pos:
-            return cli.safePrint(res('<red>Error:<reset> <gray>Missing subcommand<reset>'))
-    else:
-        return cmd.func(cli)
-
-    cname = p.pos[0]
-    child = cmd.children.get(cname)
-    if not child:
-        return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown subcommand {cname}<reset>'))
-
-    if 'help' in p.flags and len(p.pos) == 1:
-        return cli.safePrint(help_child(child))
-
-    if 'help' in p.flags and len(p.pos) >= 2:
-        an = p.pos[1]
-        meta = child.args_meta.get(an)
-        if not meta:
-            return cli.safePrint(res(f'<red>Error:<reset> <gray>Unknown argument {an}<reset>'))
-        return cli.safePrint(help_arg(child, meta))
-
-    arg = p.pos[1] if len(p.pos) > 1 else None
-    if child.requires_arg and arg is None:
-        return cli.safePrint(res(f'<red>Error:<reset> <gray>Subcommand {child.name} requires an argument<reset>'))
-
-    g = child.func.__globals__
-    for n, ps in child.params.items():
-        if n in p.params:
-            try:
-                v = ps.type_(p.params[n])
-            except:
-                v = ps.default
-        else:
-            v = ps.default
-
-        def wrap(f=ps.func, val=v):
-            def w():
-                return f(val)
-            return w
-
-        g[n] = wrap()
-
-    for n, fs in child.flags.items():
-        present = n in p.flags
-
-        def wrap(f=fs.func, pr=present):
-            def w():
-                return pr
-            return w
-
-        g[n] = wrap()
-
-    f = child.func
-    if f.__code__.co_argcount >= 2:
-        return f(cli, arg)
-    return f(cli)