hungerlib 4.24.2__tar.gz → 4.25.dev4__tar.gz

{hungerlib-4.24.2/src/hungerlib.egg-info → hungerlib-4.25.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hungerlib
-Version: 4.24.2
+Version: 4.25.dev4
 Summary: Powerful automation library for Pterodactyl.
 Author: iFamished
 License: MIT

{hungerlib-4.24.2 → hungerlib-4.25.dev4}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hungerlib"
-version = "4.24.2"
+version = "4.25-dev.4"
 description = "Powerful automation library for Pterodactyl."
 readme = "README.md"
 requires-python = ">=3.9"

{hungerlib-4.24.2 → hungerlib-4.25.dev4}/src/hungerlib/bridgeclient.py

@@ -1,19 +1,163 @@
 import time
+import threading
+import re
 import requests
 from .utils.exceptions import HungerBridgeError, InvalidLevelError, InvalidModeError
 
 
+class Stream:
+    '''Streaming wrapper for HungerBridge /stream/logs SSE endpoint.'''
+    def __init__(
+        self,
+        base_url: str,
+        headers: dict,
+        history_handler=None,
+        newline_handler=None
+    ):
+        self.url = base_url.rstrip('/') + '/stream/logs'
+        self.headers = headers
+
+        self.history_handler = history_handler or self._default_history_handler
+        self.newline_handler = newline_handler or self._default_newline_handler
+
+        self.raw_stream = []
+        self.sanitized_stream = []
+        self.timestamped_stream = {}
+
+        self._thread = None
+        self._stop_event = None
+        self._session = None
+
+    def _default_history_handler(self, historic_lines: list):
+        for line in historic_lines:
+            clean = self.sanitize(line)
+            ts = self.extractTimestamp(clean)
+            self.raw_stream.append(line)
+            self.sanitized_stream.append(clean)
+            if ts is not None:
+                self.timestamped_stream[ts] = clean
+
+    def _default_newline_handler(self, line: str):
+        clean = self.sanitize(line)
+        ts = self.extractTimestamp(clean)
+        self.raw_stream.append(line)
+        self.sanitized_stream.append(clean)
+        if ts is not None:
+            self.timestamped_stream[ts] = clean
+
+    def connect(self, keepalive: int = 15):
+        if self._thread and self._thread.is_alive():
+            return
+
+        self._stop_event = threading.Event()
+        self._session = requests.Session()
+
+        def _run():
+            history_phase = True
+            history_lines = []
+            history_deadline = time.time() + keepalive
+
+            try:
+                with self._session.get(
+                    self.url,
+                    headers=self.headers,
+                    stream=True
+                ) as r:
+                    if not r.ok:
+                        raise HungerBridgeError(f'HungerBridge error {r.status_code}: {r.text}')
+
+                    for raw in r.iter_lines(decode_unicode=True):
+                        if self._stop_event.is_set():
+                            break
+                        if not raw:
+                            continue
+                        if not raw.startswith('data:'):
+                            continue
+
+                        line = raw[len('data:'):].lstrip()
+
+                        if history_phase:
+                            history_lines.append(line)
+                            if time.time() >= history_deadline:
+                                try:
+                                    self.history_handler(history_lines)
+                                except Exception:
+                                    pass
+                                history_phase = False
+                            continue
+
+                        try:
+                            self.newline_handler(line)
+                        except Exception:
+                            pass
+
+            except Exception as e:
+                raise HungerBridgeError(f'Log stream failed: {e}')
+            finally:
+                if self._session:
+                    try:
+                        self._session.close()
+                    except Exception:
+                        pass
+                self._thread = None
+                self._session = None
+                self._stop_event = None
+
+        self._thread = threading.Thread(
+            target=_run,
+            name='HungerBridgeStream',
+            daemon=True
+        )
+        self._thread.start()
+
+    def disconnect(self):
+        if self._stop_event:
+            self._stop_event.set()
+        if self._session:
+            try:
+                self._session.close()
+            except Exception:
+                pass
+        self._thread = None
+        self._session = None
+        self._stop_event = None
+
+    def isConnected(self) -> bool: return self._thread is not None and self._thread.is_alive()
+
+    def getRaw(self) -> list: return list(self.raw_stream)
+    def getSanitized(self) -> list: return list(self.sanitized_stream)
+    def getTimestamped(self) -> dict: return dict(self.timestamped_stream)
+
+    @staticmethod
+    def sanitize(line: str) -> str:
+        ansi_re = re.compile(r'\x1b\[[0-9;]*m')
+        return ansi_re.sub('', line).rstrip
+
+    @staticmethod
+    def extractTimestamp(line: str):
+        m = re.match(r'\[([0-9]{2}:[0-9]{2}:[0-9]{2})\]', line)
+        if not m:
+            return None
+        return m.group(1)
+
+
 class BridgeClient:
-    '''
-    Python client for the HungerBridge v2 API
-    '''
-    def __init__(self, url: str, token: str):
+    '''Python client for the HungerBridge v2 API'''
+    def __init__(self, url: str, token: str, history_handler=None, newline_handler=None):
         self.base = url.rstrip('/') + '/v2/'
         self.headers = {
             'X-Auth-Key': token,
             'Content-Type': 'application/json'
         }
 
+        self.stream = Stream(
+            base_url=self.base,
+            headers=self.headers,
+
+            history_handler=history_handler,
+            newline_handler=newline_handler
+        )
+
     # internal helpers
     def _post(self, path: str, payload):
         r = requests.post(self.base + path, headers=self.headers, json=payload)
@@ -87,9 +231,7 @@ class BridgeClient:
         return None
 
     def log(self, message: str, level: str = 'info') -> dict:
-        '''
-        Logs a message to the server console
-        '''
+        '''Logs a message to the server console'''
         valid_levels = ['info', 'warn', 'error', None]
         if level not in valid_levels:
             raise InvalidLevelError(f'\'{level}\' is not a valid log level')
@@ -106,9 +248,7 @@ class BridgeClient:
 
     # convenience getters
     def getPing(self) -> int:
-        '''
-        Round-trip latency (ms) measured client-side.
-        '''
+        '''Round-trip latency (ms) measured client-side.'''
         start = time.time()
         self.v2_ping()
         end = time.time()

{hungerlib-4.24.2 → hungerlib-4.25.dev4}/src/hungerlib/servers/minecraft.py

@@ -16,8 +16,11 @@ class MinecraftServer(GenericServer):
         server_id: str,
         server_domain: str,
         server_port: int,
+
         bridge_url: str,
         bridge_token: str,
+        history_handler=None,
+        newline_handler=None,
     ):
         super().__init__(
             name,
@@ -30,18 +33,17 @@ class MinecraftServer(GenericServer):
         self.server_port = server_port
 
         # HungerBridge client
-        self.bridge = BridgeClient(bridge_url, bridge_token)
+        self.bridge = BridgeClient(bridge_url, bridge_token, history_handler=history_handler, newline_handler=newline_handler)
 
 
-    # basic information properties
-    @property
-    def bridge_version(self) -> str | None:
+    # basic getter methods
+    def getBridgeVersion(self) -> str | None:
         return self.bridge.getVersion()
-    @property
-    def version(self) -> str | None:
+
+    def getVersion(self) -> str | None:
         return self.bridge.getMinecraftVersion()
-    @property
-    def platform(self) -> str | None:
+
+    def getPlatform(self) -> str | None:
         return self.bridge.getPlatform()
 
 
@@ -54,15 +56,7 @@ class MinecraftServer(GenericServer):
         else:
             raise InvalidModeError(f"Invalid mode: '{mode}'")
 
-    @property
-    def player_count(self) -> int:
-        return self.getPlayers(mode='count') or 0
-    @property
-    def player_list(self) -> list[str]:
-        return self.getPlayers('list') or []
-
-    @property
-    def max_players(self) -> int:
+    def getMaxPlayers(self) -> int:
         '''
         Runs the 'list' command and extracts the max player count.
         Expected format:
@@ -96,10 +90,6 @@ class MinecraftServer(GenericServer):
             return None
         return round(value, rounding) if rounding is not None else value
 
-    @property
-    def tps(self) -> float | None:
-        return self.getTPS()
-
 
     # commands
     def sendConsoleCommand(
@@ -122,3 +112,11 @@ class MinecraftServer(GenericServer):
         safe = message.replace('"', '\\"')
         cmd = f'tellraw @a {{"text":"{safe}"}}'
         return self.bridge.runCommand(cmd, show_console=True)
+
+    # stream passthrough methods
+    def connectStream(self, keepalive: int=15): self.bridge.stream.connect(keepalive)
+    def disconnectStream(self): self.bridge.stream.disconnect()
+    def isStreamConnected(self): self.bridge.stream.isConnected()
+    def getRawStream(self): self.bridge.streamgetRaw()
+    def getSanitizedStream(self): self.bridge.stream.getSanitized()
+    def getTimestampedStream(self): self.bridge.stream.getTimestamped()

{hungerlib-4.24.2 → hungerlib-4.25.dev4/src/hungerlib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hungerlib
-Version: 4.24.2
+Version: 4.25.dev4
 Summary: Powerful automation library for Pterodactyl.
 Author: iFamished
 License: MIT