serverwatcher 5.20__tar.gz → 5.22__tar.gz

{serverwatcher-5.20/src/serverwatcher.egg-info → serverwatcher-5.22}/PKG-INFO

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

{serverwatcher-5.20 → serverwatcher-5.22}/pyproject.toml

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

{serverwatcher-5.20 → serverwatcher-5.22}/src/serverwatcher/configclasses/config.py

@@ -1,4 +1,4 @@
-from hungerlib import datamap, datamap_api
+from mapres import datamap, datamap_api
 
 @datamap(syntax=datamap_api.braces, mode='config')
 class GlobalConfig:

{serverwatcher-5.20 → serverwatcher-5.22}/src/serverwatcher/configclasses/watcher.py

@@ -7,9 +7,6 @@ class WatcherConfig:
 
     watch_interval: int = 'watch_interval'
 
-    schedule_control: bool = 'schedule_control.enabled'
-    restart_soon_id: int = 'schedule_control.restart_soon_id'
-
     threshold_ram: int = 'thresholds.ram'
     threshold_cpu: int = 'thresholds.cpu'
     threshold_uptime: int = 'thresholds.uptime'
@@ -39,9 +36,6 @@ class WatcherConfig:
 class fallbacks:
     watch_interval = 300
 
-    schedule_control = False
-    restart_soon_id = 0
-
     threshold_ram = 6
     threshold_cpu = 150
     threshold_uptime = 12

{serverwatcher-5.20 → serverwatcher-5.22}/src/serverwatcher/defaultconfigs/watcher.yaml

@@ -1,9 +1,5 @@
 watch_interval: 300      # in seconds
 
-schedule_control:
-  enabled: False
-  restart_soon_id: 0     # replace this with a real schedule id
-
 thresholds:
   ram: 6
   cpu: 150

serverwatcher-5.22/src/serverwatcher/validator.py

@@ -0,0 +1,218 @@
+import sys
+from dataclasses import fields
+
+from hungerlib import utils, loadConfig
+
+from serverwatcher.configclasses.config import GlobalConfig
+from serverwatcher.configclasses.messages import MessagesConfig
+from serverwatcher.configclasses.watcher import WatcherConfig
+
+
+utils.clearTerminal()
+errors = []
+warnings = []
+defaults = []
+
+
+def validate_key_types(config_obj, schema):
+    for f in fields(schema):
+        if f.name.startswith("__"):
+            continue
+
+        expected_type = f.type
+        value = getattr(config_obj, f.name, None)
+
+        # allow None (missing + no fallback) to be handled by other validators
+        if value is None:
+            continue
+
+        if not isinstance(value, expected_type):
+            errors.append(
+                f'{schema.__name__}.{f.name}: expected {expected_type.__name__}, '
+                f'got "{type(value).__name__}" ({value!r})'
+            )
+
+
+def check_field(config_obj, name, allow_fallback=True):
+    """
+    Unified check for:
+    - missing YAML key (config.raw.<name> is None)
+    - fallback usage (config.<name> == config.fallbacks.<name>)
+    - whether fallback is allowed or not
+    """
+    raw = config_obj.raw
+    fb = config_obj.fallbacks
+
+    val = getattr(config_obj, name)
+    raw_val = getattr(raw, name)
+    fb_val = getattr(fb, name)
+
+    # 1) YAML key missing
+    if raw_val is None:
+        if allow_fallback:
+            warnings.append(f'{name}: key does not exist, using fallback "{fb_val}"')
+        else:
+            errors.append(f'{name}: key does not exist and fallback is not allowed')
+        return
+
+    # 2) YAML key exists but value equals fallback
+    if val == fb_val and not allow_fallback:
+        defaults.append(f'{name}: must not be left default or empty (got "{val}")')
+
+
+def validate_global_config(config):
+    c = config
+
+    # Fallback policy:
+    # - NOT allowed (must be set by user): panel_url, panel_api_key,
+    #   server_id, server_domain, bridge_token
+    # - Allowed: everything else
+
+    # timezone
+    check_field(c, "timezone")
+    if c.timezone == "":
+        errors.append('timezone: must not be empty')
+
+    # panel
+    check_field(c, "panel_name")
+    check_field(c, "panel_url", allow_fallback=False)
+    check_field(c, "panel_api_key", allow_fallback=False)
+
+    if c.panel_url and not (c.panel_url.startswith("http://") or c.panel_url.startswith("https://")):
+        errors.append(f'panel_url: must start with "http://" or "https://" (got "{c.panel_url}")')
+
+    if c.panel_api_key and not c.panel_api_key.startswith("ptlc_"):
+        errors.append(f'panel_api_key: must be a valid Pterodactyl client API key (got "{c.panel_api_key}")')
+    if c.panel_api_key and c.panel_api_key.startswith("plta_"):
+        errors.append(f'panel_api_key: should not be an application key (got "{c.panel_api_key}")')
+
+    # server
+    check_field(c, "server_name")
+    check_field(c, "server_id", allow_fallback=False)
+    check_field(c, "server_domain", allow_fallback=False)
+    check_field(c, "server_port")
+    if c.server_domain and (c.server_domain.startswith("http://") or c.server_domain.startswith("https://")):
+        errors.append(f'server_domain: must not contain protocol (got "{c.server_domain}")')
+    if c.server_port is not None and not (1 <= c.server_port <= 65535):
+        errors.append(f'server_port: must be 1–65535 (got "{c.server_port}")')
+
+    # tps_command
+    check_field(c, "tps_command")
+
+    # hungerbridge
+    check_field(c, "bridge_token", allow_fallback=False)
+    check_field(c, "bridge_port")
+    if c.bridge_port is not None and not (1 <= c.bridge_port <= 65535):
+        errors.append(f'bridge_port: must be 1–65535 (got "{c.bridge_port}")')
+
+    # logger
+    check_field(c, "enable_logging")
+    check_field(c, "logger_name")
+    check_field(c, "log_path")
+    check_field(c, "info_prefix")
+    check_field(c, "warn_prefix")
+    check_field(c, "error_prefix")
+
+    # terminal
+    check_field(c, "clear_terminal")
+    check_field(c, "handle_keyboard_interrupt")
+
+
+def validate_watcher_config(watcherconfig):
+    c = watcherconfig
+    raw = c.raw
+    fb = c.fallbacks
+
+    # basic numeric sanity
+    if c.restart_wait_seconds <= 0:
+        errors.append(f'restart_wait_seconds: must be > 0 (got {c.restart_wait_seconds})')
+
+    if c.threshold_cpu <= 0:
+        errors.append(f'threshold_cpu: must be > 0 (got {c.threshold_cpu})')
+
+    if c.threshold_ram <= 0:
+        errors.append(f'threshold_ram: must be > 0 (got {c.threshold_ram})')
+
+    if c.threshold_tps <= 0 or c.threshold_tps > 20:
+        errors.append(f'threshold_tps: must be 1–20 (got {c.threshold_tps})')
+
+    # snap_minutes: must be a non-empty list of ints 0–59
+    if raw.snap_minutes is None:
+        warnings.append(f'snap_minutes: key does not exist, using fallback "{fb.snap_minutes}"')
+
+    if not isinstance(c.snap_minutes, list) or not c.snap_minutes:
+        errors.append(f'snap_minutes: must be a non-empty list of minute marks (got {c.snap_minutes!r})')
+    else:
+        bad = [m for m in c.snap_minutes if not isinstance(m, int) or not (0 <= m <= 59)]
+        if bad:
+            errors.append(f'snap_minutes: all values must be integers 0–59 (bad values: {bad})')
+
+
+def validate_messages_config(messages):
+    pass
+    # m = messages
+
+    # for f in fields(MessagesConfig):
+    #     if f.name.startswith("__"):
+    #         continue
+    #     value = getattr(m, f.name)
+    #     if not isinstance(value, str) or value.strip() == "":
+    #         errors.append(f'MessagesConfig.{f.name}: must be a non-empty string')
+
+
+def validate_all():
+    config = loadConfig(GlobalConfig)
+    messages = loadConfig(MessagesConfig)
+    watcherconfig = loadConfig(WatcherConfig)
+
+    # type checks
+    validate_key_types(config, GlobalConfig)
+    validate_key_types(messages, MessagesConfig)
+    validate_key_types(watcherconfig, WatcherConfig)
+
+    # semantic checks
+    validate_global_config(config)
+    validate_watcher_config(watcherconfig)
+    validate_messages_config(messages)
+
+    # if too many critical defaults, assume "not configured at all"
+    critical_default_keys = [
+        "panel_url",
+        "panel_api_key",
+        "server_id",
+        "server_domain",
+        "bridge_token",
+    ]
+    critical_defaults_used = [
+        d for d in defaults
+        if any(d.startswith(k) for k in critical_default_keys)
+    ]
+
+    if len(critical_defaults_used) >= 3:
+        print('❌ CONFIG VALIDATION FAILED:\nIt looks like you haven\'t configured this yet! Please change these defaults:')
+        for d in critical_defaults_used:
+            print(' -', d)
+        sys.exit(1)
+
+    if errors or defaults:
+        print('❌ CONFIG VALIDATION FAILED:')
+        for e in errors:
+            print(' -', e)
+        for d in defaults:
+            print(' -', d)
+        if warnings:
+            print('\nWarnings:')
+            for w in warnings:
+                print(' -', w)
+        sys.exit(1)
+
+    if warnings:
+        print('⚠️  CONFIG VALIDATION WARNINGS:')
+        for w in warnings:
+            print(' -', w)
+
+    print('✅ All configs are valid.')
+
+
+if __name__ == '__main__':
+    validate_all()

{serverwatcher-5.20 → serverwatcher-5.22}/src/serverwatcher/watcher.py

@@ -2,40 +2,31 @@ import os
 import time
 from zoneinfo import ZoneInfo
 
-from hungerlib import servers, MessageRouter, loadConfig, utils, datamap_api, mapit
+from hungerlib import servers, MessageRouter, loadConfig, utils
+from mapres import MapResolver, maps
 
 from serverwatcher.configclasses.config import GlobalConfig
 from serverwatcher.configclasses.messages import MessagesConfig
 from serverwatcher.configclasses.watcher import WatcherConfig
 
 
-
 class ServerWatcher:
     def __init__(self):
         self.config = loadConfig(GlobalConfig)
         self.messages = loadConfig(MessagesConfig)
         self.watcherconfig = loadConfig(WatcherConfig)
 
-        datamap_api.setGlobalMaps(
-            utils.ASCII_COLOR_MAP,
-            utils.TIME_MAP(self.config.timezone),
-            self.config,
-            self.messages,
-            self.watcherconfig,
-        )
+        # resolver for internal mapping
+        self.resolver = MapResolver()
+        self.res = self.resolver.res
 
+        # panel + server
         self.panel = servers.Panel(
             name=self.config.panel_name,
             url=self.config.panel_url,
             api_key=self.config.panel_api_key,
         )
 
-        self.origin = servers.Generic(
-            name="Origin",
-            panel=self.panel,
-            server_id=self.config.origin_server_id
-        )
-
         self.server = servers.Minecraft(
             name=self.config.server_name,
             panel=self.panel,
@@ -47,18 +38,54 @@ class ServerWatcher:
             tpsCommand=self.config.tps_command,
         )
 
-        logger_name = mapit(self.config.logger_name, server_name=self.config.server_name)
-        
+        # logger name
+        logger_name = self.res(
+            self.config.logger_name,
+            server_name=self.config.server_name
+        )
+
+        # router using mapres
         self.router = MessageRouter(
             name=logger_name,
             Servers=[self.server],
             log_path=self.config.log_path,
 
-            origin_maps = [utils.ASCII_COLOR_MAP, utils.TIME_MAP(self.config.timezone), self.config, self.messages, self.watcherconfig],
-            destination_maps = [utils.ASCII_COLOR_MAP, utils.TIME_MAP(self.config.timezone), self.config, self.messages, self.watcherconfig],
-            broadcast_maps = [utils.MC_COLOR_MAP, utils.TIME_MAP(self.config.timezone), self.config, self.messages, self.watcherconfig],
-            file_maps = [utils.STRIP_COLOR_MAP, utils.TIME_MAP(self.config.timezone), self.config, self.messages, self.watcherconfig],
-            prefix_maps = [utils.ASCII_COLOR_MAP, utils.TIME_MAP(self.config.timezone)],
+            origin_maps=[
+                maps.ascii_colors,
+                maps.time_tk(self.config.timezone),
+                self.config,
+                self.messages,
+                self.watcherconfig
+            ],
+
+            destination_maps=[
+                maps.ascii_colors,
+                maps.time_tk(self.config.timezone),
+                self.config,
+                self.messages,
+                self.watcherconfig
+            ],
+
+            broadcast_maps=[
+                maps.mc_colors,
+                maps.time_tk(self.config.timezone),
+                self.config,
+                self.messages,
+                self.watcherconfig
+            ],
+
+            file_maps=[
+                maps.strip_colors,
+                maps.time_tk(self.config.timezone),
+                self.config,
+                self.messages,
+                self.watcherconfig
+            ],
+
+            prefix_maps=[
+                maps.ascii_colors,
+                maps.time_tk(self.config.timezone)
+            ],
 
             info_prefix=self.config.info_prefix,
             warn_prefix=self.config.warn_prefix,
@@ -72,9 +99,6 @@ class ServerWatcher:
         raise SystemExit
 
     def restart_and_wait(self):
-        if self.watcherconfig.schedule_control:
-            self.origin.disableSchedule(self.watcherconfig.restart_soon_id)
-
         self.server.restart()
         self.router.info(self.messages.restart_action_sent)
         time.sleep(self.watcherconfig.restart_wait_seconds)
@@ -93,7 +117,10 @@ class ServerWatcher:
             self.router.error(self.messages.server_failed_restart)
 
     def schedule_restart(self, minutes):
-        info = utils.snapSchedule(minimumMinutes=minutes, snapMinutes=tuple(sorted(self.watcherconfig.snap_minutes)))
+        info = utils.snapSchedule(
+            minimumMinutes=minutes,
+            snapMinutes=tuple(sorted(self.watcherconfig.snap_minutes))
+        )
         scheduled = info["scheduled"]
 
         local_time = scheduled.astimezone(self.tz)
@@ -101,34 +128,38 @@ class ServerWatcher:
 
         self.router.broadcast(self.messages.broadcast_restart_at, time=time_str)
 
+        # minute callbacks
         minute_callbacks = {
             int(k.split("_")[1]): (
                 lambda raw=self.messages.as_map()[k]:
-                    self.router.broadcast(mapit(raw)),
-                    self.router.origin(raw)
+                    (self.router.broadcast(self.res(raw)),
+                     self.router.origin(raw))
             )
             for k in self.messages.as_map()
             if k.startswith("minute_")
         }
 
+        # second callbacks
         second_callbacks = {
             int(k.split("_")[1]): (
                 lambda raw=self.messages.as_map()[k]:
-                    self.router.broadcast(mapit(raw)),
-                    self.router.origin(raw)
+                    (self.router.broadcast(self.res(raw)),
+                     self.router.origin(raw))
             )
             for k in self.messages.as_map()
             if k.startswith("second_")
         }
 
-        utils.runCountdownEvents(target_time=scheduled, minute_callbacks=minute_callbacks, second_callbacks=second_callbacks)
+        utils.runCountdownEvents(
+            target_time=scheduled,
+            minute_callbacks=minute_callbacks,
+            second_callbacks=second_callbacks
+        )
 
     def evaluate(self):
-        # Lets Pterodactyl know the server is online, then clears terminal and uses user-defined startup key
         self.router.info("ServerWatcher is running!")
         utils.clearTerminal()
 
-        # Configurable start message
         self.router.info(self.messages.startup)
 
         if not utils.validateAll(self.panel, self.server):
@@ -143,36 +174,36 @@ class ServerWatcher:
         restart_reasons = []
         no_restart_reasons = []
 
-        if self.watcherconfig.schedule_control and self.server.getSchedule(self.watcherconfig.restart_soon_id)["is_active"]:
-            restart_reasons.append(self.messages.reason_restart_soon)
-            pro += self.watcherconfig.weight_restart_soon
-
         if snap.ram >= self.watcherconfig.threshold_ram:
-            restart_reasons.append(mapit(self.messages.reason_ram, ram=snap.ram, threshold=self.watcherconfig.threshold_ram))
+            restart_reasons.append(
+                self.res(self.messages.reason_ram, ram=snap.ram, threshold=self.watcherconfig.threshold_ram)
+            )
             pro += int(round(snap.ram, 0) - (self.watcherconfig.threshold_ram - 1))
 
         if snap.cpu >= self.watcherconfig.threshold_cpu:
-            restart_reasons.append(mapit(self.messages.reason_cpu, cpu=snap.cpu, threshold=self.watcherconfig.threshold_cpu))
+            restart_reasons.append(
+                self.res(self.messages.reason_cpu, cpu=snap.cpu, threshold=self.watcherconfig.threshold_cpu)
+            )
             pro += self.watcherconfig.weight_cpu
 
         if snap.uptime // 3600 >= self.watcherconfig.threshold_uptime:
             restart_reasons.append(
-                mapit(self.messages.reason_uptime, uptime=snap.uptime_formatted, threshold=self.watcherconfig.threshold_uptime)
+                self.res(self.messages.reason_uptime, uptime=snap.uptime_formatted, threshold=self.watcherconfig.threshold_uptime)
             )
             pro += self.watcherconfig.weight_uptime
 
         if (snap.tps if snap.tps is not None else 20) <= self.watcherconfig.threshold_tps:
-            restart_reasons.append(mapit(self.messages.reason_tps, tps=snap.tps, threshold=self.watcherconfig.threshold_tps))
+            restart_reasons.append(self.res(self.messages.reason_tps, tps=snap.tps, threshold=self.watcherconfig.threshold_tps))
             pro += self.watcherconfig.weight_tps
 
         if snap.uptime // 60 < self.watcherconfig.threshold_min_uptime:
-            no_restart_reasons.append(mapit(self.messages.reason_low_uptime, uptime=snap.uptime_formatted))
+            no_restart_reasons.append(self.res(self.messages.reason_low_uptime, uptime=snap.uptime_formatted))
             anti += self.watcherconfig.weight_low_uptime
 
         if snap.players > 0:
             verb = "are" if snap.players != 1 else "is"
             plural = "players" if snap.players != 1 else "player"
-            no_restart_reasons.append(mapit(self.messages.reason_players, verb=verb, count=snap.players, plural=plural))
+            no_restart_reasons.append(self.res(self.messages.reason_players, verb=verb, count=snap.players, plural=plural))
             anti += snap.players * self.watcherconfig.weight_per_player
 
         if restart_reasons:

{serverwatcher-5.20 → serverwatcher-5.22/src/serverwatcher.egg-info}/PKG-INFO

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

serverwatcher-5.20/src/serverwatcher/validator.py

@@ -1,139 +0,0 @@
-import sys
-from dataclasses import fields
-from hungerlib import utils, loadConfig
-
-from serverwatcher.configclasses.config import GlobalConfig
-from serverwatcher.configclasses.messages import MessagesConfig
-from serverwatcher.configclasses.watcher import WatcherConfig
-
-utils.clearTerminal()
-
-def deep_get_attr(obj, dotted):
-    parts = dotted.split('.')
-    cur = obj
-    for p in parts:
-        if not hasattr(cur, p):
-            return None
-        cur = getattr(cur, p)
-    return cur
-
-def validate_type(name, value, expected_type, errors):
-    if not isinstance(value, expected_type):
-        errors.append(f'{name}: expected {expected_type.__name__}, got {type(value).__name__}')
-
-def validate_positive(name, value, errors):
-    if isinstance(value, (int, float)) and value < 0:
-        errors.append(f'{name}: must be >= 0 (got {value})')
-
-def validate_nonempty(name, value, errors):
-    if isinstance(value, str) and value.strip() == '':
-        errors.append(f'{name}: cannot be empty')
-
-def validate_dataclass(config_obj, schema, errors):
-    for f in fields(schema):
-        name = f.name
-        expected_type = f.type
-        value = deep_get_attr(config_obj, name)
-
-        validate_type(name, value, expected_type, errors)
-
-        if expected_type is str:
-            validate_nonempty(name, value, errors)
-
-        if expected_type in (int, float):
-            validate_positive(name, value, errors)
-
-def validate_global_config(config, errors):
-    if config.server_port <= 0 or config.server_port > 65535:
-        errors.append(f'server_port: must be 1–65535 (got {config.server_port})')
-
-    if config.bridge_port <= 0 or config.bridge_port > 65535:
-        errors.append(f'bridge_port: must be 1–65535 (got {config.bridge_port})')
-
-    if len(config.bridge_token) < 8:
-        errors.append(f'bridge_token: must be 8 or more characters (got {config.bridge_token}, {len(config.bridge_token)} characters)')
-
-def validate_watcher_config(watcherconfig, errors):
-    if watcherconfig.restart_wait_seconds < 1:
-        errors.append(f'restart_wait_seconds: must be > 0 (got {watcherconfig.restart_wait_seconds})')
-
-    if watcherconfig.threshold_cpu <= 0:
-        errors.append(f'threshold_cpu: must be > 0 (got {watcherconfig.threshold_cpu})')
-
-    if watcherconfig.threshold_ram <= 0:
-        errors.append(f'threshold_ram: must be > 0 (got {watcherconfig.threshold_ram})')
-
-    if watcherconfig.threshold_tps <= 0 or watcherconfig.threshold_tps > 20:
-        errors.append(f'threshold_tps: must be 1–20 (got {watcherconfig.threshold_tps})')
-
-def validate_messages_config(messages, errors):
-    for f in fields(MessagesConfig):
-        value = getattr(messages, f.name)
-        if isinstance(value, str) and '{prefix}' not in value:
-            pass
-
-
-# fallback detection
-def ensure_no_global_defaults(config, defaults):
-    fb = config.fallbacks
-
-    if config.panel_url == fb.panel_url:
-        defaults.append('panel_url')
-
-    if config.panel_api_key == fb.panel_api_key:
-        defaults.append('panel_api_key')
-
-    if config.server_id == fb.server_id:
-        defaults.append('server_id')
-
-    if config.server_domain == fb.server_domain:
-        defaults.append('server_domain')
-
-    if config.bridge_token == fb.bridge_token:
-        defaults.append('bridge_token')
-
-def ensure_no_watcher_defaults(watcherconfig, defaults):
-    fb = watcherconfig.fallbacks
-
-    if watcherconfig.schedule_control and watcherconfig.restart_soon_id == fb.restart_soon_id:
-        defaults.append('restart_soon_id')
-
-# main validation entrypoint
-def validate_all():
-    errors = []
-    defaults = []
-
-    config = loadConfig(GlobalConfig)
-    messages = loadConfig(MessagesConfig)
-    watcher = loadConfig(WatcherConfig)
-
-    validate_dataclass(config, GlobalConfig, errors)
-    validate_dataclass(messages, MessagesConfig, errors)
-    validate_dataclass(watcher, WatcherConfig, errors)
-
-    validate_global_config(config, errors)
-    validate_messages_config(messages, errors)
-    validate_watcher_config(watcher, errors)
-
-    ensure_no_global_defaults(config, defaults)
-    ensure_no_watcher_defaults(watcher, defaults)
-
-    if len(defaults) >= 5:
-        print('❌ CONFIG VALIDATION FAILED:\nIt looks like you haven\'t configured this yet! Please change these defaults:')
-        for d in defaults:
-            print(' -', d)
-        sys.exit(1)
-
-    if errors or defaults:
-        print('❌ CONFIG VALIDATION FAILED:')
-        for e in errors:
-            print(' -', e)
-        for d in defaults:
-            print(' -', d, ': must not be left default')
-        sys.exit(1)
-
-    print('✅ All configs are valid.')
-
-
-if __name__ == '__main__':
-    validate_all()