serverwatcher 6.dev57__tar.gz → 6.dev59__tar.gz

{serverwatcher-6.dev57/src/serverwatcher.egg-info → serverwatcher-6.dev59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: serverwatcher
-Version: 6.dev57
+Version: 6.dev59
 Summary: A HungerLib-powered Minecraft server automation engine.
 Author: iFamished
 License: GPL-3.0

{serverwatcher-6.dev57 → serverwatcher-6.dev59}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "serverwatcher"
-version = "6-dev.57"
+version = "6-dev.59"
 description = "A HungerLib-powered Minecraft server automation engine."
 readme = "README.md"
 requires-python = ">=3.14"

{serverwatcher-6.dev57 → serverwatcher-6.dev59}/src/serverwatcher/watchercli.py

@@ -28,15 +28,8 @@ class WatcherCLI(LiveCLI):
         self.safePrint(res('<yellow>-----------------------------------'), write_buffer=False)
         self.safePrint('', write_buffer=False)
 
-@command('stats', namespace=True)
-def stats(self):
-    '''
-    Retrieve and print server statistics
-    '''
-    pass
-
-@stats.child('get')
-def stats_get(self, arg=None):
+@command('stats')
+def stats(self, arg=None):
     '''
     Retrieve and print all or specific server statistics
     '''
@@ -83,17 +76,17 @@ def stats_get(self, arg=None):
             return self.safePrint('Unknown stat')
     self.safePrint(f'{name}: {value}{unit}')
 
-@stats.get.param('rounding', type=int, default=2)
+@stats.param('rounding', type=int, default=2)
 def rounding(value):
     '''The decimal place to round to'''
     return value
 
-@stats.get.param('mode', type=str, default='current')
+@stats.param('mode', type=str, default='current')
 def mode(value):
     '''The mode for TPS. Accepted: current, 1m, 5m, tick_time'''
     return value
 
-@stats.get.flag('raw')
+@stats.flag('raw')
 def raw():
     '''Return the raw value instead of the formatted string'''
     return True
@@ -133,9 +126,7 @@ def view_watcher(self):
 
 @command('clear')
 def clear(self):
-    '''
-    Clear the CLI terminal
-    '''
+    '''Clear the CLI terminal'''
     if not no_buffer():
         self.buffer.clear()
     utils.clearTerminal()

{serverwatcher-6.dev57 → serverwatcher-6.dev59/src/serverwatcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: serverwatcher
-Version: 6.dev57
+Version: 6.dev59
 Summary: A HungerLib-powered Minecraft server automation engine.
 Author: iFamished
 License: GPL-3.0

{serverwatcher-6.dev57 → serverwatcher-6.dev59}/src/serverwatcher.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 pyproject.toml
 src/serverwatcher/__init__.py
 src/serverwatcher/__main__.py
-src/serverwatcher/livecli.py
 src/serverwatcher/validator.py
 src/serverwatcher/watcher.py
 src/serverwatcher/watchercli.py

serverwatcher-6.dev57/src/serverwatcher/livecli.py

@@ -1,447 +0,0 @@
-from dataclasses import dataclass
-import cmd
-import sys
-import termios
-import tty
-import asyncio
-import inspect
-
-from mapres import res, ascii_colors, setGlobalMaps
-
-setGlobalMaps(ascii_colors)
-
-
-COMMANDS = {}
-
-@dataclass
-class ParamSpec:
-    name: str
-    type_: type
-    default: object
-    func: callable
-    desc: str | None
-
-@dataclass
-class FlagSpec:
-    name: str
-    func: callable
-    desc: str | None
-
-@dataclass
-class ArgMeta:
-    name: str
-    params: list[str]
-    flags: list[str]
-    required_params: set[str]
-    required_flags: set[str]
-
-class ChildSpec:
-    def __init__(self, parent, name, func):
-        self.parent = parent
-        self.name = name
-        self.func = func
-        self.params = {}
-        self.flags = {}
-        self.args_meta = {}
-        self.desc = self._doc(func)
-        self._extract_args_block()
-        self._parse_args_meta()
-        self._infer_arg_requirement()
-
-    def _doc(self, f):
-        d = f.__doc__
-        return d.strip().splitlines()[0].strip() if d else None
-
-    def _extract_args_block(self):
-        src = inspect.getsource(self.func)
-        lines = src.splitlines()
-        block = []
-        in_block = False
-        for line in lines:
-            s = line.strip()
-            if s.startswith('__args__'):
-                in_block = True
-                continue
-            if in_block:
-                if s.startswith(("'''", '"""')):
-                    if not block:
-                        continue
-                    else:
-                        break
-                block.append(line)
-        if block:
-            raw = '\n'.join(l.strip() for l in block)
-            setattr(self.func, '__args__', raw)
-
-    def _parse_args_meta(self):
-        raw = getattr(self.func, '__args__', None)
-        if not raw:
-            return
-        for line in raw.splitlines():
-            s = line.strip()
-            if not s:
-                continue
-            if ':' in s:
-                arg, rest = s.split(':', 1)
-                arg = arg.strip()
-                tokens = [t.strip() for t in rest.split(',') if t.strip()]
-            else:
-                arg = s
-                tokens = []
-            params = []
-            flags = []
-            req_p = set()
-            req_f = set()
-            for t in tokens:
-                required = True
-                if t.startswith('[') and t.endswith(']'):
-                    required = False
-                    t = t[1:-1].strip()
-                if t.startswith('--'):
-                    f = t[2:]
-                    flags.append(f)
-                    if required:
-                        req_f.add(f)
-                else:
-                    params.append(t)
-                    if required:
-                        req_p.add(t)
-            self.args_meta[arg] = ArgMeta(arg, params, flags, req_p, req_f)
-
-    def _infer_arg_requirement(self):
-        sig = inspect.signature(self.func)
-        ps = list(sig.parameters.values())
-        if len(ps) == 1:
-            self.requires_arg = False
-            self.optional_arg = False
-        elif len(ps) == 2:
-            p = ps[1]
-            if p.default is inspect._empty:
-                self.requires_arg = True
-                self.optional_arg = False
-            else:
-                self.requires_arg = False
-                self.optional_arg = True
-        else:
-            self.requires_arg = False
-            self.optional_arg = False
-
-    def param(self, name, type=str, default=None):
-        def deco(f):
-            py = name.replace('-', '_')
-            d = f.__doc__.strip().splitlines()[0].strip() if f.__doc__ else None
-            self.params[py] = ParamSpec(name, type, default, f, d)
-            return f
-        return deco
-
-    def flag(self, name):
-        def deco(f):
-            py = name.replace('-', '_')
-            d = f.__doc__.strip().splitlines()[0].strip() if f.__doc__ else None
-            self.flags[py] = FlagSpec(name, f, d)
-            return f
-        return deco
-
-class CommandSpec:
-    def __init__(self, name, func, namespace=False):
-        self.name = name
-        self.func = func
-        self.children = {}
-        self.params = {}
-        self.flags = {}
-        self.desc = self._doc(func)
-
-        self.is_namespace = namespace
-
-    def _doc(self, f):
-        d = f.__doc__
-        return d.strip().splitlines()[0].strip() if d else None
-
-    def param(self, name, type=str, default=None):
-        def deco(f):
-            py = name.replace('-', '_')
-            d = f.__doc__.strip().splitlines()[0].strip() if f.__doc__ else None
-            self.params[py] = ParamSpec(name, type, default, f, d)
-            return f
-        return deco
-
-    def flag(self, name):
-        def deco(f):
-            py = name.replace('-', '_')
-            d = f.__doc__.strip().splitlines()[0].strip() if f.__doc__ else None
-            self.flags[py] = FlagSpec(name, f, d)
-            return f
-        return deco
-
-    def child(self, name):
-        def deco(f):
-            c = ChildSpec(self, name, f)
-            self.children[name] = c
-            setattr(self, name, c)
-            return c
-        return deco
-
-class CommandDSL:
-    def __call__(self, name, namespace=False):
-        def deco(f):
-            spec = CommandSpec(name, f, namespace=namespace)
-            COMMANDS[name] = spec
-            return spec
-        return deco
-
-command = CommandDSL()
-
-@dataclass
-class ParsedArgs:
-    sub: str | None
-    pos: list[str]
-    flags: dict[str, bool]
-    params: dict[str, str]
-
-def parse_line(raw):
-    raw = raw.strip()
-    if not raw:
-        return ParsedArgs(None, [], {}, {})
-    parts = raw.split()
-    sub = parts[0]
-    pos = []
-    flags = {}
-    params = {}
-    for t in parts[1:]:
-        if t.startswith('--'):
-            flags[t[2:]] = True
-        elif ':' in t:
-            k, v = t.split(':', 1)
-            params[k.lower()] = v
-        else:
-            pos.append(t)
-    return ParsedArgs(sub, pos, flags, params)
-
-def help_command(cmd):
-    lines = []
-    d = cmd.desc or 'No description'
-    lines.append(res(f'<bold><yellow>{cmd.name}<reset>: <gray>{d}<reset>'))
-
-    if cmd.children:
-        if cmd.is_namespace:
-            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> <dark_gray>[<reset>child<dark_gray>]<reset>')
-    else:
-        u = res(f'<aqua>Usage:<reset> <gold>{cmd.name}<reset>')
-
-    if cmd.flags:
-        u += res(' <dark_gray>[<reset>--flags<dark_gray>]<reset>')
-
-    lines.append(u)
-
-    if cmd.flags:
-        lines.append('')
-        lines.append(res('\0    <light_purple>Flags:<reset>'))
-        for n, fs in cmd.flags.items():
-            d = fs.desc or 'No description'
-            lines.append(res(f'\0        <blue>--{fs.name}<reset>: <gray>{d}<reset>'))
-
-    if cmd.children:
-        lines.append('')
-        lines.append(res('\0    <light_purple>Children:<reset>'))
-        for n, c in cmd.children.items():
-            cd = c.desc or 'No description'
-            lines.append(res(f'\0        <green>{n}<reset>: <gray>{cd}<reset>'))
-
-    return '\n'.join(lines)
-
-def help_child(child):
-    lines = []
-    d = child.desc or 'No description'
-    p = child.parent.name
-    lines.append(res(f'<bold><green>{child.name}<reset>: <gray>{d}<reset>'))
-
-    u = res(f'<aqua>Usage:<reset> <gold>{p}<reset> <green>{child.name}<reset>')
-    if child.requires_arg:
-        u += res(' <dark_gray>\\<<reset>arg<dark_gray>\\><reset>')
-    elif child.optional_arg:
-        u += res(' <dark_gray>[<reset>arg<dark_gray>]<reset>')
-    if child.params:
-        u += res(' <dark_gray>[<reset>params<dark_gray>]<reset>')
-    if child.flags:
-        u += res(' <dark_gray>[<reset>--flags<dark_gray>]<reset>')
-    lines.append(u)
-
-    if child.args_meta:
-        lines.append('')
-        lines.append(res('\0    <light_purple>Args:<reset>'))
-        for a, m in child.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))
-
-    if child.params:
-        lines.append('')
-        lines.append(res('\0    <light_purple>Params:<reset>'))
-        for n, ps in child.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>'))
-
-    if child.flags:
-        lines.append('')
-        lines.append(res('\0    <light_purple>Flags:<reset>'))
-        for n, fs in child.flags.items():
-            d = fs.desc or 'No description'
-            lines.append(res(f'\0        <blue>--{fs.name}<reset>: <gray>{d}<reset>'))
-
-    return '\n'.join(lines)
-
-def help_arg(child, meta):
-    lines = []
-    p = child.parent.name
-    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>{p}<reset> <green>{child.name}<reset> <aqua>{a}<reset>')
-    req = []
-    opt = []
-    for pn in meta.params:
-        ps = child.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 = child.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 = child.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>'))
-    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)
-
-class LiveCLI(cmd.Cmd):
-    prompt = ''
-
-    def safePrint(self, msg='', end='\n', write_buffer=True):
-        text = str(msg)
-        if write_buffer and hasattr(self, 'buffer'):
-            buf = self.buffer
-            if getattr(buf, 'enabled', False) and text.strip():
-                buf.captured.append(text.rstrip('\n'))
-        print(text, end=end)
-
-    def read_line_raw(self):
-        fd = sys.stdin.fileno()
-        old = termios.tcgetattr(fd)
-        try:
-            tty.setraw(fd)
-            chars = []
-            while True:
-                ch = sys.stdin.read(1)
-                if ch in ('\r', '\n'):
-                    break
-                chars.append(ch)
-            return ''.join(chars)
-        finally:
-            termios.tcsetattr(fd, termios.TCSADRAIN, old)
-
-    async def run(self):
-        while True:
-            line = await asyncio.to_thread(self.read_line_raw)
-            line = line.strip()
-            if not line:
-                continue
-
-            # buffer the command (but not view commands)
-            buf = getattr(self, 'buffer', None)
-            if buf is not None and getattr(buf, 'enabled', False):
-                if not line.startswith(("view", "clear")):
-                    buf.captured.append(line)
-
-            # execute command
-            stop = await asyncio.to_thread(self.onecmd, line)
-            self.safePrint("", write_buffer=False)
-            if stop:
-                break
-
-    def onecmd(self, line):
-        return dispatch(self, line)