serverwatcher 2.2.4__tar.gz → 3.1__tar.gz

{serverwatcher-2.2.4/src/serverwatcher.egg-info → serverwatcher-3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: serverwatcher
-Version: 2.2.4
+Version: 3.1
 Summary: A HungerLib-powered Minecraft server automation engine.
 Author: iFamished
 License: MIT

{serverwatcher-2.2.4 → serverwatcher-3.1}/pyproject.toml

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

{serverwatcher-2.2.4 → serverwatcher-3.1}/src/serverwatcher/__init__.py

@@ -9,6 +9,7 @@ except PackageNotFoundError:
 from .watcher import ServerWatcher
 from .config import WatcherConfig
 from .messages import WatcherMessages
+from .schema import validate_config_schema, validate_messages_schema
 
 
 __all__ = [
@@ -16,4 +17,6 @@ __all__ = [
     'ServerWatcher',
     'WatcherConfig',
     'WatcherMessages',
+    'validate_config_schema',
+    'validate_messages_schema',
 ]

serverwatcher-3.1/src/serverwatcher/config/global.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+@dataclass
+class GlobalConfig:
+    panel: dict
+    origin: dict
+    server: dict

serverwatcher-3.1/src/serverwatcher/config/messages.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+
+@dataclass
+class MessagesConfig:
+    prefix: str
+    broadcast_restart_at: str
+    broadcast_minute: dict = field(default_factory=dict)
+    broadcast_second: dict = field(default_factory=dict)
+
+    log_start: str = ""
+    log_validation_fail: str = ""
+    log_validation_ok: str = ""
+    log_immediate_restart: str = ""
+    log_no_restart: str = ""
+    log_scheduled: str = ""
+    log_gap_low: str = ""
+    log_gap_high: str = ""
+
+    reason_restart_soon: str = ""
+    reason_ram: str = ""
+    reason_cpu: str = ""
+    reason_uptime: str = ""
+    reason_tps: str = ""
+    reason_low_uptime: str = ""
+    reason_players: str = ""

serverwatcher-3.1/src/serverwatcher/config/watcher.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+@dataclass
+class WatcherConfig:
+    restart_soon_schedule_id: int
+    origin_disable_schedule_id: int
+
+    ram_threshold: int
+    cpu_threshold: int
+    uptime_hours_threshold: int
+    tps_threshold: float
+
+    weight_restart_soon: int
+    weight_ram: int
+    weight_cpu: int
+    weight_uptime: int
+    weight_tps: int
+
+    weight_low_uptime: int
+    weight_per_player: int
+
+    low_gap_minutes: int
+    high_gap_minutes: int
+
+    restart_wait_seconds: int
+    restart_online_timeout: int
+    restart_online_interval: int
+
+    logger_name_template: str
+    log_path: str
+    console_backspaces: int
+    timezone: str

serverwatcher-3.1/src/serverwatcher/schema.py

@@ -0,0 +1,45 @@
+from typing import Dict, Any, List
+
+from hungerlib.addons import validate_required_keys
+
+
+def validate_config_schema(raw: Dict[str, Any]) -> list[str]:
+    errors: List[str] = []
+
+    # top-level sections
+    errors += validate_required_keys(raw, ["panel", "origin", "server", "watcher"], "root")
+
+    panel = raw.get("panel", {})
+    origin = raw.get("origin", {})
+    server = raw.get("server", {})
+    watcher = raw.get("watcher", {})
+
+    errors += validate_required_keys(panel, ["name", "url", "api_key"], "panel")
+    errors += validate_required_keys(origin, ["server_id"], "origin")
+    errors += validate_required_keys(
+        server,
+        ["name", "server_id", "domain", "port", "rcon_port", "rcon_password", "tps_command"],
+        "server",
+    )
+
+    # simple sanity checks (optional but nice)
+    if "port" in server and not isinstance(server["port"], int):
+        errors.append("[server] 'port' must be an integer")
+    if "rcon_port" in server and not isinstance(server["rcon_port"], int):
+        errors.append("[server] 'rcon_port' must be an integer")
+
+    # watcher numeric sanity
+    if "ram_threshold" in watcher and watcher["ram_threshold"] <= 0:
+        errors.append("[watcher] 'ram_threshold' must be > 0")
+    if "cpu_threshold" in watcher and watcher["cpu_threshold"] <= 0:
+        errors.append("[watcher] 'cpu_threshold' must be > 0")
+
+    return errors
+
+
+def validate_messages_schema(raw: Dict[str, Any]) -> list[str]:
+    # you can make this as strict as you want; for now just ensure prefix exists
+    errors: List[str] = []
+    if "prefix" not in raw:
+        errors.append("[messages] Missing required key: 'prefix'")
+    return errors

serverwatcher-3.1/src/serverwatcher/watcher.py

@@ -0,0 +1,280 @@
+import os
+import time
+from zoneinfo import ZoneInfo
+
+from hungerlib import Panel, HungerLogger
+from hungerlib.servers import MinecraftServer, GenericServer
+from hungerlib.addons import (
+    clearTerminal,
+    Snapshot,
+    snapSchedule,
+    waitForOnline,
+    validateAll,
+    runCountdownEvents,
+    load_yaml,
+    map_to_dataclass,
+)
+
+# NEW CONFIG DATACLASSES
+from config.global import GlobalConfig
+from config.messages import MessagesConfig
+from config.watcher import WatcherConfig
+
+
+# ---------------------------------------------------------
+# Utility: load config or copy default from defaultconfigs/
+# ---------------------------------------------------------
+def load_or_default(path: str, default_path: str, schema):
+    """
+    Loads YAML from path. If missing, copies default_path → path.
+    Then maps YAML → dataclass.
+    """
+    if not os.path.exists(path):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(default_path, "r") as src, open(path, "w") as dst:
+            dst.write(src.read())
+
+    raw = load_yaml(path)
+    return map_to_dataclass(raw, schema)
+
+
+# ---------------------------------------------------------
+# Main Watcher
+# ---------------------------------------------------------
+class ServerWatcher:
+    def __init__(self):
+        # Load all 3 configs
+        self.global_cfg: GlobalConfig = load_or_default(
+            "config/global.yaml",
+            "defaultconfigs/global.yaml",
+            GlobalConfig
+        )
+
+        self.messages: MessagesConfig = load_or_default(
+            "config/messages.yaml",
+            "defaultconfigs/messages.yaml",
+            MessagesConfig
+        )
+
+        self.cfg: WatcherConfig = load_or_default(
+            "config/watcher.yaml",
+            "defaultconfigs/watcher.yaml",
+            WatcherConfig
+        )
+
+        # PANEL
+        p = self.global_cfg.panel
+        self.panel = Panel(
+            name=p["name"],
+            url=p["url"],
+            api_key=p["api_key"],
+        )
+
+        # ORIGIN
+        o = self.global_cfg.origin
+        self.origin = GenericServer(
+            name="Origin",
+            panel=self.panel,
+            server_id=o["server_id"],
+        )
+
+        # SERVER
+        s = self.global_cfg.server
+        self.server = MinecraftServer(
+            name=s["name"],
+            panel=self.panel,
+            server_id=s["server_id"],
+            server_domain=s["domain"],
+            server_port=s["port"],
+            rcon_port=s["rcon_port"],
+            rcon_password=s["rcon_password"],
+            tpsCommand=s["tps_command"],
+        )
+
+        # LOGGER (fully configurable)
+        logger_name = self.cfg.logger_name_template.format(
+            server_name=s["name"]
+        )
+
+        self.log = HungerLogger(
+            name=logger_name,
+            server=self.server,
+            log_path=self.cfg.log_path,
+            console_backspaces=self.cfg.console_backspaces,
+        )
+
+        # TIMEZONE
+        self.tz = ZoneInfo(self.cfg.timezone)
+
+    # -----------------------------------------------------
+    # Utility: format messages with prefix
+    # -----------------------------------------------------
+    def fmt(self, template: str, **kwargs):
+        return template.format(prefix=self.messages.prefix, **kwargs)
+
+    # -----------------------------------------------------
+    # Shutdown
+    # -----------------------------------------------------
+    def shutdown(self):
+        self.log.info("Shutting down ServerWatcher.")
+        raise SystemExit
+
+    # -----------------------------------------------------
+    # Restart logic
+    # -----------------------------------------------------
+    def restart_and_wait(self):
+        self.origin.disableSchedule(self.cfg.restart_soon_schedule_id)
+        self.server.restart()
+        self.log.info("Restart action sent. Waiting...")
+        time.sleep(self.cfg.restart_wait_seconds)
+
+        self.log.warn("Checking server status...")
+        alive = waitForOnline(
+            self.server,
+            timeout=self.cfg.restart_online_timeout,
+            interval=self.cfg.restart_online_interval,
+        )
+
+        if alive:
+            self.log.info("Server is back online!")
+            self.server.sendBroadcast(
+                f"{self.messages.prefix}<green>Restart successful!"
+            )
+            self.origin.enableSchedule(self.cfg.origin_disable_schedule_id)
+        else:
+            self.log.error("Server failed to restart!")
+
+    # -----------------------------------------------------
+    # Schedule restart
+    # -----------------------------------------------------
+    def schedule_restart(self, minutes):
+        info = snapSchedule(minimumMinutes=minutes)
+        scheduled = info["scheduled"]
+
+        local_time = scheduled.astimezone(self.tz)
+        time_str = local_time.strftime("%I:%M %p")
+
+        self.server.sendBroadcast(
+            self.fmt(self.messages.broadcast_restart_at, time=time_str)
+        )
+
+        minute_callbacks = {
+            m: (lambda msg=self.fmt(self.messages.broadcast_minute[m]):
+                self.server.sendBroadcast(msg))
+            for m in self.messages.broadcast_minute
+        }
+
+        second_callbacks = {
+            s: (lambda msg=self.fmt(self.messages.broadcast_second[s]):
+                self.server.sendBroadcast(msg))
+            for s in self.messages.broadcast_second
+        }
+
+        runCountdownEvents(
+            target_time=scheduled,
+            minute_callbacks=minute_callbacks,
+            second_callbacks=second_callbacks,
+        )
+
+    # -----------------------------------------------------
+    # Main evaluation logic
+    # -----------------------------------------------------
+    def evaluate(self):
+        self.log.info(self.messages.log_start)
+
+        if not validateAll(self.panel, self.server):
+            self.log.error(self.messages.log_validation_fail)
+            self.shutdown()
+
+        self.server.refresh()
+        snap = Snapshot(self.server, 2, True)
+
+        pro = 0
+        anti = 0
+        restart_reasons = []
+        no_restart_reasons = []
+
+        # PRO-RESTART
+        if self.server.getSchedule(self.cfg.restart_soon_schedule_id)["is_active"]:
+            restart_reasons.append(self.messages.reason_restart_soon)
+            pro += self.cfg.weight_restart_soon
+
+        if snap.ram >= self.cfg.ram_threshold:
+            restart_reasons.append(
+                self.fmt(self.messages.reason_ram, ram=snap.ram, threshold=self.cfg.ram_threshold)
+            )
+            pro += round(snap.ram, 0) - 5
+
+        if snap.cpu >= self.cfg.cpu_threshold:
+            restart_reasons.append(
+                self.fmt(self.messages.reason_cpu, cpu=snap.cpu, threshold=self.cfg.cpu_threshold)
+            )
+            pro += self.cfg.weight_cpu
+
+        if snap.uptime // 3600 >= self.cfg.uptime_hours_threshold:
+            restart_reasons.append(
+                self.fmt(self.messages.reason_uptime, uptime=snap.uptime_formatted,
+                         threshold=self.cfg.uptime_hours_threshold)
+            )
+            pro += self.cfg.weight_uptime
+
+        if snap.tps <= self.cfg.tps_threshold:
+            restart_reasons.append(
+                self.fmt(self.messages.reason_tps, tps=snap.tps, threshold=self.cfg.tps_threshold)
+            )
+            pro += self.cfg.weight_tps
+
+        # ANTI-RESTART
+        if snap.uptime // 60 < 30:
+            no_restart_reasons.append(
+                self.fmt(self.messages.reason_low_uptime, uptime=snap.uptime_formatted)
+            )
+            anti += self.cfg.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(
+                self.fmt(self.messages.reason_players, verb=verb, count=snap.players, plural=plural)
+            )
+            anti += snap.players * self.cfg.weight_per_player
+
+        # LOGGING
+        for r in restart_reasons:
+            self.log.warn(f"- {r}")
+        for r in no_restart_reasons:
+            self.log.warn(f"- {r}")
+
+        self.log.warn(f"Pro-restart:  {pro}")
+        self.log.warn(f"Anti-restart: {anti}")
+
+        gap = abs(pro - anti)
+
+        if pro == 0:
+            self.log.info(self.messages.log_no_restart)
+            return
+
+        if pro > anti and snap.players == 0:
+            self.log.info(self.messages.log_immediate_restart)
+            self.restart_and_wait()
+            return
+
+        self.log.info(self.messages.log_scheduled)
+
+        if gap <= 2:
+            self.log.warn(self.fmt(self.messages.log_gap_low, gap=gap))
+            self.schedule_restart(self.cfg.low_gap_minutes)
+        else:
+            self.log.warn(self.fmt(self.messages.log_gap_high, gap=gap))
+            self.schedule_restart(self.cfg.high_gap_minutes)
+
+        self.restart_and_wait()
+
+    # -----------------------------------------------------
+    # Main loop
+    # -----------------------------------------------------
+    def run(self):
+        clearTerminal()
+        while True:
+            self.evaluate()
+            time.sleep(60)

{serverwatcher-2.2.4 → serverwatcher-3.1/src/serverwatcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: serverwatcher
-Version: 2.2.4
+Version: 3.1
 Summary: A HungerLib-powered Minecraft server automation engine.
 Author: iFamished
 License: MIT

{serverwatcher-2.2.4 → serverwatcher-3.1}/src/serverwatcher.egg-info/SOURCES.txt

@@ -2,11 +2,13 @@ LICENSE
 README.md
 pyproject.toml
 src/serverwatcher/__init__.py
-src/serverwatcher/config.py
-src/serverwatcher/messages.py
+src/serverwatcher/schema.py
 src/serverwatcher/watcher.py
 src/serverwatcher.egg-info/PKG-INFO
 src/serverwatcher.egg-info/SOURCES.txt
 src/serverwatcher.egg-info/dependency_links.txt
 src/serverwatcher.egg-info/requires.txt
-src/serverwatcher.egg-info/top_level.txt
+src/serverwatcher.egg-info/top_level.txt
+src/serverwatcher/config/global.py
+src/serverwatcher/config/messages.py
+src/serverwatcher/config/watcher.py

serverwatcher-2.2.4/src/serverwatcher/config.py

@@ -1,33 +0,0 @@
-from dataclasses import dataclass
-
-@dataclass
-class WatcherConfig:
-    # schedule IDs
-    restart_soon_schedule_id: int = 13
-    origin_disable_schedule_id: int = 11
-
-    # thresholds
-    ram_threshold: int = 6
-    cpu_threshold: int = 150
-    uptime_hours_threshold: int = 12
-    tps_threshold: float = 19.5
-
-    # weights (pro)
-    weight_restart_soon: int = 3
-    weight_ram: int = 1
-    weight_cpu: int = 1
-    weight_uptime: int = 1
-    weight_tps: int = 1
-
-    # weights (anti)
-    weight_low_uptime: int = 5
-    weight_per_player: int = 1
-
-    # scheduling
-    low_gap_minutes: int = 120
-    high_gap_minutes: int = 60
-
-    # restart timing
-    restart_wait_seconds: int = 45
-    restart_online_timeout: int = 120
-    restart_online_interval: int = 2

serverwatcher-2.2.4/src/serverwatcher/messages.py

@@ -1,43 +0,0 @@
-from dataclasses import dataclass, field
-
-@dataclass
-class WatcherMessages:
-    prefix: str = "<aqua>[Server Watcher]"
-
-    # broadcast templates
-    broadcast_restart_at: str = "{prefix} The server will restart at {time} CDT."
-
-    broadcast_minute: dict = field(default_factory=lambda: {
-        120: "{prefix} Restart in 2 hours!",
-        60:  "{prefix} Restart in 1 hour!",
-        45:  "{prefix} Restart in 45 minutes!",
-        30:  "{prefix} Restart in 30 minutes!",
-        15:  "{prefix} Restart in 15 minutes!",
-        5:   "{prefix} Restart in 5 minutes!",
-        1:   "{prefix} Restart in 1 minute!",
-    })
-
-    broadcast_second: dict = field(default_factory=lambda: {
-        s: "{prefix} Restart in " + str(s) + " seconds!"
-        for s in range(10, 0, -1)
-    })
-
-    # log messages
-    log_start: str = "ServerWatcher is running!"
-    log_validation_fail: str = "Validation FAILED"
-    log_validation_ok: str = "All validation checks succeeded."
-    log_immediate_restart: str = "Restarting immediately."
-    log_no_restart: str = "The server does not need to restart."
-    log_scheduled: str = "Restart needed, but anti-restart factors outweigh it."
-    log_gap_low: str = "Gap {gap}. Scheduling restart in 2 hours."
-    log_gap_high: str = "Gap {gap}. Scheduling restart in 1 hour."
-
-    # reason messages
-    reason_restart_soon: str = "The server is set to restart soon"
-    reason_ram: str = "RAM usage ({ram}) is higher than {threshold} GB"
-    reason_cpu: str = "CPU usage ({cpu}) is higher than {threshold}%"
-    reason_uptime: str = "Uptime {uptime} exceeds {threshold}h"
-    reason_tps: str = "TPS {tps} is lower than {threshold}"
-
-    reason_low_uptime: str = "Uptime {uptime} is shorter than 30m"
-    reason_players: str = "There {verb} {count} {plural} online"

serverwatcher-2.2.4/src/serverwatcher/watcher.py

@@ -1,263 +0,0 @@
-import time
-from zoneinfo import ZoneInfo
-
-from hungerlib import Panel, HungerLogger
-from hungerlib.servers import MinecraftServer, GenericServer
-from hungerlib.addons import (
-    clearTerminal,
-    Snapshot,
-    snapSchedule,
-    waitForOnline,
-    validateAll,
-    runCountdownEvents,
-    ensure_yaml,
-    load_yaml,
-    map_to_dataclass
-)
-
-from .config import WatcherConfig
-from .messages import WatcherMessages
-
-
-DEFAULT_CONFIG = {
-    "panel": {
-        "name": "My Panel",
-        "url": "https://example.com",
-        "api_key": "CHANGE_ME",
-    },
-    "origin": {
-        "server_id": "CHANGE_ME",
-    },
-    "server": {
-        "name": "My SMP",
-        "server_id": "CHANGE_ME",
-        "domain": "example.com",
-        "port": 25565,
-        "rcon_port": 25575,
-        "rcon_password": "password",
-        "tps_command": "ticks",
-    },
-    "watcher": {},
-    "messages": {},
-}
-
-
-class ServerWatcher:
-    def __init__(self, config_path: str = "config.yaml"):
-        # ensure config exists, then load it
-        ensure_yaml(config_path, DEFAULT_CONFIG)
-        raw = load_yaml(config_path)
-
-        # map watcher + messages sections into your dataclasses
-        self.cfg: WatcherConfig = map_to_dataclass(raw.get("watcher", {}), WatcherConfig)
-        self.msg: WatcherMessages = map_to_dataclass(
-            raw.get("messages", {}), WatcherMessages
-        )
-
-        # panel / origin / server wiring from YAML
-        p = raw["panel"]
-        self.panel = Panel(
-            name=p["name"],
-            url=p["url"],
-            api_key=p["api_key"],
-        )
-
-        o = raw["origin"]
-        self.origin = GenericServer(
-            name="Origin",
-            panel=self.panel,
-            server_id=o["server_id"],
-        )
-
-        s = raw["server"]
-        self.server = MinecraftServer(
-            name=s["name"],
-            panel=self.panel,
-            server_id=s["server_id"],
-            server_domain=s["domain"],
-            server_port=s["port"],
-            rcon_port=s["rcon_port"],
-            rcon_password=s["rcon_password"],
-            tpsCommand=s["tps_command"],
-        )
-
-        self.log = HungerLogger(
-            name=f"ServerWatcher-{s['name']}",
-            server=self.server,
-            log_path="/home/container/logs/",
-            console_backspaces=8,
-        )
-
-    def fmt(self, template: str, **kwargs):
-        return template.format(prefix=self.msg.prefix, **kwargs)
-
-    def shutdown(self):
-        self.log.info("Shutting down ServerWatcher.")
-        raise SystemExit
-
-    def restart_and_wait(self):
-        self.origin.disableSchedule(self.cfg.origin_disable_schedule_id)
-        self.server.restart()
-        self.log.info("Restart action sent. Waiting...")
-        time.sleep(self.cfg.restart_wait_seconds)
-
-        self.log.warn("Checking server status...")
-        alive = waitForOnline(
-            self.server,
-            timeout=self.cfg.restart_online_timeout,
-            interval=self.cfg.restart_online_interval,
-        )
-
-        if alive:
-            self.log.info("Server is back online!")
-            self.server.sendBroadcast(f"{self.msg.prefix}<green>Restart successful!")
-            self.origin.enableSchedule(self.cfg.origin_disable_schedule_id)
-        else:
-            self.log.error("Server failed to restart!")
-
-    def schedule_restart(self, minutes):
-        info = snapSchedule(minimumMinutes=minutes)
-        scheduled = info["scheduled"]
-
-        cst = scheduled.astimezone(ZoneInfo("America/Chicago"))
-        time_in_cdt = cst.strftime("%I:%M %p")
-
-        self.server.sendBroadcast(
-            self.fmt(self.msg.broadcast_restart_at, time=time_in_cdt)
-        )
-
-        minute_callbacks = {
-            m: (lambda msg=self.fmt(self.msg.broadcast_minute[m]): self.server.sendBroadcast(msg))
-            for m in self.msg.broadcast_minute
-        }
-
-        second_callbacks = {
-            s: (lambda msg=self.fmt(self.msg.broadcast_second[s]): self.server.sendBroadcast(msg))
-            for s in self.msg.broadcast_second
-        }
-
-        runCountdownEvents(
-            target_time=scheduled,
-            minute_callbacks=minute_callbacks,
-            second_callbacks=second_callbacks,
-        )
-
-    def evaluate(self):
-        self.log.info(self.msg.log_start)
-
-        if not validateAll(self.panel, self.server):
-            self.log.error(self.msg.log_validation_fail)
-            self.shutdown()
-
-        self.server.refresh()
-        snap = Snapshot(self.server, 2, True)
-
-        pro = 0
-        anti = 0
-        restart_reasons = []
-        no_restart_reasons = []
-
-        # PRO-RESTART
-        if self.server.getSchedule(self.cfg.restart_soon_schedule_id)["is_active"]:
-            restart_reasons.append(self.msg.reason_restart_soon)
-            pro += self.cfg.weight_restart_soon
-
-        if snap.ram >= self.cfg.ram_threshold:
-            restart_reasons.append(
-                self.fmt(
-                    self.msg.reason_ram,
-                    ram=snap.ram,
-                    threshold=self.cfg.ram_threshold,
-                )
-            )
-            pro += round(snap.ram, 0) - 5
-
-        if snap.cpu >= self.cfg.cpu_threshold:
-            restart_reasons.append(
-                self.fmt(
-                    self.msg.reason_cpu,
-                    cpu=snap.cpu,
-                    threshold=self.cfg.cpu_threshold,
-                )
-            )
-            pro += self.cfg.weight_cpu
-
-        if snap.uptime // 3600 >= self.cfg.uptime_hours_threshold:
-            restart_reasons.append(
-                self.fmt(
-                    self.msg.reason_uptime,
-                    uptime=snap.uptime_formatted,
-                    threshold=self.cfg.uptime_hours_threshold,
-                )
-            )
-            pro += self.cfg.weight_uptime
-
-        if snap.tps <= self.cfg.tps_threshold:
-            restart_reasons.append(
-                self.fmt(
-                    self.msg.reason_tps,
-                    tps=snap.tps,
-                    threshold=self.cfg.tps_threshold,
-                )
-            )
-            pro += self.cfg.weight_tps
-
-        # ANTI-RESTART
-        if snap.uptime // 60 < 30:
-            no_restart_reasons.append(
-                self.fmt(
-                    self.msg.reason_low_uptime,
-                    uptime=snap.uptime_formatted,
-                )
-            )
-            anti += self.cfg.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(
-                self.fmt(
-                    self.msg.reason_players,
-                    verb=verb,
-                    count=snap.players,
-                    plural=plural,
-                )
-            )
-            anti += snap.players * self.cfg.weight_per_player
-
-        # LOGGING
-        for r in restart_reasons:
-            self.log.warn(f"- {r}")
-        for r in no_restart_reasons:
-            self.log.warn(f"- {r}")
-
-        self.log.warn(f"Pro-restart:  {pro}")
-        self.log.warn(f"Anti-restart: {anti}")
-
-        gap = abs(pro - anti)
-
-        if pro == 0:
-            self.log.info(self.msg.log_no_restart)
-            return
-
-        if pro > anti and snap.players == 0:
-            self.log.info(self.msg.log_immediate_restart)
-            self.restart_and_wait()
-            return
-
-        self.log.info(self.msg.log_scheduled)
-
-        if gap <= 2:
-            self.log.warn(self.fmt(self.msg.log_gap_low, gap=gap))
-            self.schedule_restart(self.cfg.low_gap_minutes)
-        else:
-            self.log.warn(self.fmt(self.msg.log_gap_high, gap=gap))
-            self.schedule_restart(self.cfg.high_gap_minutes)
-
-        self.restart_and_wait()
-
-    def run(self):
-        clearTerminal()
-        while True:
-            self.evaluate()
-            time.sleep(60)