rlstatsapi 0.1.0__tar.gz → 0.1.1__tar.gz

{rlstatsapi-0.1.0/src/rlstatsapi.egg-info → rlstatsapi-0.1.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: rlstatsapi
-Version: 0.1.0
+Version: 0.1.1
 Summary: Rocket League Stats API client
 Author: Manuel Cabral
 License: MIT
 Project-URL: Homepage, https://github.com/manucabral/RocketLeagueStatsAPI
-Keywords: rocket-league,stats,websocket,asyncio
+Keywords: rocket-league,stats,socket,asyncio
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: License :: OSI Approved :: MIT License
@@ -17,30 +17,38 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# rlstatsapi
+# RL Stats API
 
-Simple and fast Python client to read Rocket League Stats API events.
+`rlstatsapi` is a simple and fast Python client for reading live Rocket League Stats API events over a local TCP socket.
 
 ## Install
 
+From PyPI:
+
 ```bash
-pip install -e .
+pip install rlstatsapi
 ```
 
-## Configure Rocket League
+From GitHub (latest `main`):
+
+```bash
+pip install git+https://github.com/nania/RocketLeagueStatsAPI.git
+```
 
-Before starting the game, edit:
+## Rocket League setup
+
+Before launching Rocket League, edit:
 
 `<Install Dir>\TAGame\Config\DefaultStatsAPI.ini`
 
-Minimum required values:
+Use at least:
 
-- `PacketSendRate=60` (any value > 0)
+- `PacketSendRate=30` (any value `> 0` enables the exporter)
 - `Port=49123`
 
-Then restart Rocket League.
+Restart the game after changing the file.
 
-## Quick usage
+## Quick start
 
 ```python
 import asyncio
@@ -66,9 +74,13 @@ asyncio.run(main())
 
 ## Public API
 
-- `StatsClient(...)`
-- `connect()`
-- `disconnect()`
+- `StatsClient(host="127.0.0.1", port=49123, reconnect=True, reconnect_delay=0.5, include_raw=False, queue_size=2048, connect_timeout=5.0, log_enabled=False)`
+- `connect()` / `disconnect()`
 - `on(event_name, handler)`
 - `on_any(handler)`
 - `events()`
+
+## Notes
+
+- Works for regular matches. Some fields like `MatchGuid` are only present in online/LAN contexts.
+- In current builds this endpoint may behave as plain TCP JSON stream instead of websocket upgrade. This library handles the TCP stream format.

rlstatsapi-0.1.1/README.md

@@ -0,0 +1,67 @@
+# RL Stats API
+
+`rlstatsapi` is a simple and fast Python client for reading live Rocket League Stats API events over a local TCP socket.
+
+## Install
+
+From PyPI:
+
+```bash
+pip install rlstatsapi
+```
+
+From GitHub (latest `main`):
+
+```bash
+pip install git+https://github.com/nania/RocketLeagueStatsAPI.git
+```
+
+## Rocket League setup
+
+Before launching Rocket League, edit:
+
+`<Install Dir>\TAGame\Config\DefaultStatsAPI.ini`
+
+Use at least:
+
+- `PacketSendRate=30` (any value `> 0` enables the exporter)
+- `Port=49123`
+
+Restart the game after changing the file.
+
+## Quick start
+
+```python
+import asyncio
+import logging
+from rlstatsapi import StatsClient
+
+logging.basicConfig(level=logging.INFO)
+
+
+async def main() -> None:
+    client = StatsClient(log_enabled=True)
+    client.on_any(lambda msg: print(msg.event, msg.data))
+
+    await client.connect()
+    try:
+        await asyncio.Event().wait()
+    finally:
+        await client.disconnect()
+
+
+asyncio.run(main())
+```
+
+## Public API
+
+- `StatsClient(host="127.0.0.1", port=49123, reconnect=True, reconnect_delay=0.5, include_raw=False, queue_size=2048, connect_timeout=5.0, log_enabled=False)`
+- `connect()` / `disconnect()`
+- `on(event_name, handler)`
+- `on_any(handler)`
+- `events()`
+
+## Notes
+
+- Works for regular matches. Some fields like `MatchGuid` are only present in online/LAN contexts.
+- In current builds this endpoint may behave as plain TCP JSON stream instead of websocket upgrade. This library handles the TCP stream format.

{rlstatsapi-0.1.0 → rlstatsapi-0.1.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rlstatsapi"
-version = "0.1.0"
+version = "0.1.1"
 description = "Rocket League Stats API client"
 readme = "README.md"
 requires-python = ">=3.11"
 license = { text = "MIT" }
 authors = [{ name = "Manuel Cabral" }]
-keywords = ["rocket-league", "stats", "websocket", "asyncio"]
+keywords = ["rocket-league", "stats", "socket", "asyncio"]
 classifiers = [
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",

{rlstatsapi-0.1.0 → rlstatsapi-0.1.1}/src/rlstatsapi/client.py

@@ -9,7 +9,6 @@ from collections import defaultdict
 from typing import Any, AsyncIterator, Awaitable, Callable
 
 from .models import EventMessage
-from ._websocket import SimpleWebSocket, connect_websocket
 
 Handler = Callable[[EventMessage], Awaitable[None] | None]
 
@@ -41,7 +40,8 @@ class StatsClient:
         self._handlers_any: list[Handler] = []
         self._logger = logging.getLogger("rlstatsapi")
 
-        self._ws: SimpleWebSocket | None = None
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
         self._reader_task: asyncio.Task[None] | None = None
         self._stopping = False
 
@@ -58,10 +58,12 @@ class StatsClient:
         self._stopping = True
         self._log("disconnect requested")
 
-        if self._ws is not None:
+        if self._writer is not None:
             with contextlib.suppress(Exception):
-                await self._ws.close()
-            self._ws = None
+                self._writer.close()
+                await self._writer.wait_closed()
+            self._writer = None
+            self._reader = None
 
         if self._reader_task is not None:
             self._reader_task.cancel()
@@ -83,14 +85,13 @@ class StatsClient:
     async def _run(self) -> None:
         while not self._stopping:
             try:
-                self._log(f"connecting to ws://{self.host}:{self.port}")
-                self._ws = await connect_websocket(
-                    host=self.host,
-                    port=self.port,
+                self._log(f"connecting to tcp://{self.host}:{self.port}")
+                self._reader, self._writer = await asyncio.wait_for(
+                    asyncio.open_connection(host=self.host, port=self.port),
                     timeout=self.connect_timeout,
                 )
-                self._log("websocket connected")
-                await self._read_loop(self._ws)
+                self._log("tcp socket connected")
+                await self._read_loop(self._reader)
             except asyncio.CancelledError:
                 self._log("reader task cancelled")
                 raise
@@ -102,22 +103,48 @@ class StatsClient:
                 self._log(f"reconnecting in {self.reconnect_delay:.2f}s")
                 await asyncio.sleep(self.reconnect_delay)
             finally:
-                if self._ws is not None:
+                if self._writer is not None:
                     with contextlib.suppress(Exception):
-                        await self._ws.close()
-                    self._ws = None
-                    self._log("websocket closed")
-
-    async def _read_loop(self, ws: SimpleWebSocket) -> None:
+                        self._writer.close()
+                        await self._writer.wait_closed()
+                    self._writer = None
+                    self._reader = None
+                    self._log("tcp socket closed")
+
+    async def _read_loop(self, reader: asyncio.StreamReader) -> None:
+        decoder = json.JSONDecoder()
+        buffer = ""
         while not self._stopping:
-            raw = await ws.recv_text()
-            message = _parse_message(raw, include_raw=self.include_raw)
-            if message is None:
-                self._log("ignored invalid message (json/envelope)")
-                continue
+            chunk = await reader.read(4096)
+            if not chunk:
+                raise ConnectionAbortedError("Socket closed by peer")
+            buffer += chunk.decode("utf-8", errors="ignore")
+
+            while True:
+                lstripped = buffer.lstrip()
+                if not lstripped:
+                    buffer = ""
+                    break
+                if lstripped is not buffer:
+                    buffer = lstripped
+
+                try:
+                    decoded, end_idx = decoder.raw_decode(buffer)
+                except json.JSONDecodeError:
+                    break
+
+                raw = buffer[:end_idx]
+                buffer = buffer[end_idx:]
+
+                message = _parse_message_obj(
+                    decoded, raw=raw, include_raw=self.include_raw
+                )
+                if message is None:
+                    self._log("ignored invalid message (json/envelope)")
+                    continue
 
-            await self._queue.put(message)
-            await self._dispatch(message)
+                await self._queue.put(message)
+                await self._dispatch(message)
 
     async def _dispatch(self, message: EventMessage) -> None:
         handlers = self._handlers_any + self._handlers_by_event.get(message.event, [])
@@ -137,15 +164,20 @@ class StatsClient:
             self._logger.info("[StatsClient] %s", message)
 
 
-def _parse_message(raw: str, *, include_raw: bool) -> EventMessage | None:
-    try:
-        decoded = json.loads(raw)
-    except json.JSONDecodeError:
+def _parse_message_obj(
+    decoded: Any, *, raw: str, include_raw: bool
+) -> EventMessage | None:
+    if not isinstance(decoded, dict):
         return None
-
     event = decoded.get("Event")
     data = decoded.get("Data")
 
+    if isinstance(data, str):
+        try:
+            data = json.loads(data)
+        except json.JSONDecodeError:
+            return None
+
     if not isinstance(event, str) or not isinstance(data, dict):
         return None
 

{rlstatsapi-0.1.0 → rlstatsapi-0.1.1/src/rlstatsapi.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: rlstatsapi
-Version: 0.1.0
+Version: 0.1.1
 Summary: Rocket League Stats API client
 Author: Manuel Cabral
 License: MIT
 Project-URL: Homepage, https://github.com/manucabral/RocketLeagueStatsAPI
-Keywords: rocket-league,stats,websocket,asyncio
+Keywords: rocket-league,stats,socket,asyncio
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: License :: OSI Approved :: MIT License
@@ -17,30 +17,38 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# rlstatsapi
+# RL Stats API
 
-Simple and fast Python client to read Rocket League Stats API events.
+`rlstatsapi` is a simple and fast Python client for reading live Rocket League Stats API events over a local TCP socket.
 
 ## Install
 
+From PyPI:
+
 ```bash
-pip install -e .
+pip install rlstatsapi
 ```
 
-## Configure Rocket League
+From GitHub (latest `main`):
+
+```bash
+pip install git+https://github.com/nania/RocketLeagueStatsAPI.git
+```
 
-Before starting the game, edit:
+## Rocket League setup
+
+Before launching Rocket League, edit:
 
 `<Install Dir>\TAGame\Config\DefaultStatsAPI.ini`
 
-Minimum required values:
+Use at least:
 
-- `PacketSendRate=60` (any value > 0)
+- `PacketSendRate=30` (any value `> 0` enables the exporter)
 - `Port=49123`
 
-Then restart Rocket League.
+Restart the game after changing the file.
 
-## Quick usage
+## Quick start
 
 ```python
 import asyncio
@@ -66,9 +74,13 @@ asyncio.run(main())
 
 ## Public API
 
-- `StatsClient(...)`
-- `connect()`
-- `disconnect()`
+- `StatsClient(host="127.0.0.1", port=49123, reconnect=True, reconnect_delay=0.5, include_raw=False, queue_size=2048, connect_timeout=5.0, log_enabled=False)`
+- `connect()` / `disconnect()`
 - `on(event_name, handler)`
 - `on_any(handler)`
 - `events()`
+
+## Notes
+
+- Works for regular matches. Some fields like `MatchGuid` are only present in online/LAN contexts.
+- In current builds this endpoint may behave as plain TCP JSON stream instead of websocket upgrade. This library handles the TCP stream format.

{rlstatsapi-0.1.0 → rlstatsapi-0.1.1}/src/rlstatsapi.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@ LICENSE
 README.md
 pyproject.toml
 src/rlstatsapi/__init__.py
-src/rlstatsapi/_websocket.py
 src/rlstatsapi/client.py
 src/rlstatsapi/events.py
 src/rlstatsapi/models.py

rlstatsapi-0.1.0/README.md

@@ -1,55 +0,0 @@
-# rlstatsapi
-
-Simple and fast Python client to read Rocket League Stats API events.
-
-## Install
-
-```bash
-pip install -e .
-```
-
-## Configure Rocket League
-
-Before starting the game, edit:
-
-`<Install Dir>\TAGame\Config\DefaultStatsAPI.ini`
-
-Minimum required values:
-
-- `PacketSendRate=60` (any value > 0)
-- `Port=49123`
-
-Then restart Rocket League.
-
-## Quick usage
-
-```python
-import asyncio
-import logging
-from rlstatsapi import StatsClient
-
-logging.basicConfig(level=logging.INFO)
-
-
-async def main() -> None:
-    client = StatsClient(log_enabled=True)
-    client.on_any(lambda msg: print(msg.event, msg.data))
-
-    await client.connect()
-    try:
-        await asyncio.Event().wait()
-    finally:
-        await client.disconnect()
-
-
-asyncio.run(main())
-```
-
-## Public API
-
-- `StatsClient(...)`
-- `connect()`
-- `disconnect()`
-- `on(event_name, handler)`
-- `on_any(handler)`
-- `events()`

rlstatsapi-0.1.0/src/rlstatsapi/_websocket.py

@@ -1,176 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import base64
-import hashlib
-import os
-import ssl
-from dataclasses import dataclass
-
-_WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-
-
-class WebSocketHandshakeError(ConnectionError):
-    """Raised when websocket upgrade fails."""
-
-
-@dataclass(slots=True)
-class SimpleWebSocket:
-    """Minimal stdlib websocket client optimized for receiving text frames."""
-
-    reader: asyncio.StreamReader
-    writer: asyncio.StreamWriter
-
-    async def recv_text(self) -> str:
-        opcode, payload = await self._read_frame()
-
-        if opcode == 0x8:  # close
-            await self.close()
-            raise ConnectionAbortedError("Websocket closed by peer")
-        if opcode == 0x9:  # ping
-            await self._send_pong(payload)
-            return await self.recv_text()
-        if opcode == 0xA:  # pong
-            return await self.recv_text()
-        if opcode != 0x1:
-            raise ConnectionError(f"Unsupported opcode: {opcode}")
-
-        return payload.decode("utf-8")
-
-    async def close(self) -> None:
-        if self.writer.is_closing():
-            return
-        try:
-            await self._send_frame(0x8, b"")
-        except Exception:
-            pass
-        self.writer.close()
-        await self.writer.wait_closed()
-
-    async def _send_pong(self, payload: bytes) -> None:
-        await self._send_frame(0xA, payload)
-
-    async def _send_frame(self, opcode: int, payload: bytes) -> None:
-        fin_and_opcode = 0x80 | (opcode & 0x0F)
-        mask_and_len = 0x80
-        payload_len = len(payload)
-
-        header = bytearray([fin_and_opcode])
-        if payload_len < 126:
-            header.append(mask_and_len | payload_len)
-        elif payload_len <= 0xFFFF:
-            header.append(mask_and_len | 126)
-            header.extend(payload_len.to_bytes(2, "big"))
-        else:
-            header.append(mask_and_len | 127)
-            header.extend(payload_len.to_bytes(8, "big"))
-
-        mask = os.urandom(4)
-        header.extend(mask)
-
-        masked_payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
-
-        self.writer.write(header)
-        self.writer.write(masked_payload)
-        await self.writer.drain()
-
-    async def _read_frame(self) -> tuple[int, bytes]:
-        first_two = await self.reader.readexactly(2)
-        first, second = first_two[0], first_two[1]
-
-        fin = (first & 0x80) != 0
-        opcode = first & 0x0F
-        masked = (second & 0x80) != 0
-        payload_len = second & 0x7F
-
-        if payload_len == 126:
-            payload_len = int.from_bytes(await self.reader.readexactly(2), "big")
-        elif payload_len == 127:
-            payload_len = int.from_bytes(await self.reader.readexactly(8), "big")
-
-        mask_key = await self.reader.readexactly(4) if masked else b""
-        payload = await self.reader.readexactly(payload_len)
-
-        if masked:
-            payload = bytes(b ^ mask_key[i % 4] for i, b in enumerate(payload))
-
-        if not fin:
-            raise ConnectionError("Fragmented frames are not supported")
-
-        return opcode, payload
-
-
-async def connect_websocket(
-    *,
-    host: str,
-    port: int,
-    path: str = "/",
-    timeout: float = 5.0,
-    secure: bool = False,
-) -> SimpleWebSocket:
-    """Open websocket connection via stdlib stream upgrade."""
-
-    key = base64.b64encode(os.urandom(16)).decode("ascii")
-
-    ssl_ctx = ssl.create_default_context() if secure else None
-    reader, writer = await asyncio.wait_for(
-        asyncio.open_connection(host=host, port=port, ssl=ssl_ctx),
-        timeout=timeout,
-    )
-
-    request = (
-        f"GET {path} HTTP/1.1\r\n"
-        f"Host: {host}:{port}\r\n"
-        "Upgrade: websocket\r\n"
-        "Connection: Upgrade\r\n"
-        f"Sec-WebSocket-Key: {key}\r\n"
-        "Sec-WebSocket-Version: 13\r\n"
-        "\r\n"
-    )
-
-    writer.write(request.encode("ascii"))
-    await writer.drain()
-
-    response = await _read_http_response(reader)
-    status_line = response[0]
-
-    if " 101 " not in status_line:
-        writer.close()
-        await writer.wait_closed()
-        raise WebSocketHandshakeError(f"Handshake failed: {status_line.strip()}")
-
-    headers = _parse_headers(response[1:])
-    accept = headers.get("sec-websocket-accept")
-
-    expected = base64.b64encode(
-        hashlib.sha1((key + _WS_GUID).encode("ascii")).digest()
-    ).decode("ascii")
-    if accept != expected:
-        writer.close()
-        await writer.wait_closed()
-        raise WebSocketHandshakeError("Invalid Sec-WebSocket-Accept from server")
-
-    return SimpleWebSocket(reader=reader, writer=writer)
-
-
-async def _read_http_response(reader: asyncio.StreamReader) -> list[str]:
-    lines: list[str] = []
-    while True:
-        line = (await reader.readline()).decode("iso-8859-1")
-        if not line:
-            raise WebSocketHandshakeError("Unexpected EOF during handshake")
-        lines.append(line)
-        if line == "\r\n":
-            return lines
-
-
-def _parse_headers(lines: list[str]) -> dict[str, str]:
-    headers: dict[str, str] = {}
-    for line in lines:
-        if line == "\r\n":
-            break
-        if ":" not in line:
-            continue
-        key, value = line.split(":", 1)
-        headers[key.strip().lower()] = value.strip()
-    return headers