repodnet 0.1.0__py3-none-any.whl

repod/__init__.py

@@ -0,0 +1,62 @@
+"""repod -- Modern async networking library for multiplayer games.
+
+A type-safe networking library built on asyncio and msgpack,
+designed as a modern replacement for PodSixNet.
+
+Server quick-start::
+
+    from repod import Server, Channel
+
+
+    class MyChannel(Channel):
+
+        def Network_hello(self, data: dict) -> None:
+            self.send({"action": "response", "text": "Hi!"})
+
+
+    class MyServer(Server):
+        channel_class = MyChannel
+
+
+    MyServer(host="0.0.0.0", port=5071).launch()
+
+Client quick-start::
+
+    import time
+    from repod import ConnectionListener
+
+
+    class MyClient(ConnectionListener):
+
+        def Network_connected(self, data: dict) -> None:
+            self.send({"action": "hello", "message": "Hello server!"})
+
+        def Network_response(self, data: dict) -> None:
+            print(data["text"])
+
+
+    client = MyClient()
+    client.connect("localhost", 5071)
+
+    while True:
+        client.pump()
+        time.sleep(0.01)
+"""
+
+from repod.channel import Channel
+from repod.client import Client, ConnectionListener
+from repod.constants import DEFAULT_HOST, DEFAULT_PORT
+from repod.protocol import decode, encode, read_message
+from repod.server import Server
+
+__all__ = [
+    "DEFAULT_HOST",
+    "DEFAULT_PORT",
+    "Channel",
+    "Client",
+    "ConnectionListener",
+    "Server",
+    "decode",
+    "encode",
+    "read_message",
+]

repod/channel.py

@@ -0,0 +1,214 @@
+"""Network channel representing a single connection.
+
+A :class:`Channel` represents one side of a TCP connection.  On the
+server side, each connected client gets its own ``Channel`` instance.
+
+Subclass ``Channel`` and define ``Network_{action}`` methods to handle
+specific message types::
+
+    class GameChannel(Channel):
+
+        def Network_chat(self, data: dict) -> None:
+            print(f"Chat: {data['message']}")
+
+        def Network_move(self, data: dict) -> None:
+            print(f"Player moved to {data['x']}, {data['y']}")
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import socket
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from repod.server import Server
+
+
+class Channel[S: Server]:
+    """Represents a single network connection.
+
+    Attributes:
+        addr: ``(host, port)`` tuple of the remote endpoint.
+        is_connected: Whether the connection is currently active.
+    """
+
+    def __init__(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+        server: S | None = None,
+    ) -> None:
+        """Initialize a channel with asyncio stream reader/writer.
+
+        Args:
+            reader: Async stream reader for incoming data.
+            writer: Async stream writer for outgoing data.
+            server: Optional reference to the parent
+                :class:`~repod.server.Server`.
+        """
+        self._reader = reader
+        self._writer = writer
+        self._send_queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self._receive_queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+        self._closed = False
+        self._address: tuple[str, int] = writer.get_extra_info("peername")
+        self._server: S | None = server
+        self._buffer = b""
+
+        # Disable Nagle's algorithm for low-latency real-time communication.
+        sock: socket.socket | None = writer.get_extra_info("socket")
+        if sock is not None:
+            with contextlib.suppress(OSError):
+                sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+
+    @property
+    def addr(self) -> tuple[str, int]:
+        """Remote address as a ``(host, port)`` tuple."""
+        return self._address
+
+    @property
+    def is_connected(self) -> bool:
+        """Whether this channel is still connected."""
+        return not self._closed
+
+    @property
+    def server(self) -> S:
+        """The parent :class:`~repod.server.Server` instance.
+
+        Raises:
+            RuntimeError: If the channel is not connected to a server.
+        """
+        if self._server is None:
+            raise RuntimeError("Channel is not connected to a server")
+        return self._server
+
+    def send(self, data: dict[str, Any]) -> int:
+        """Queue a message to be sent to the remote endpoint.
+
+        The dictionary is serialized with msgpack and framed with a
+        4-byte length prefix before being placed in the async send
+        queue.
+
+        Args:
+            data: Message dictionary.  Should contain an ``action`` key
+                to identify the message type on the receiver side.
+
+        Returns:
+            Number of bytes queued, or ``0`` if disconnected.
+        """
+        if self._closed:
+            return 0
+
+        from repod.protocol import encode
+
+        outgoing = encode(data)
+        self._send_queue.put_nowait(outgoing)
+        return len(outgoing)
+
+    def on_connect(self) -> None:
+        """Called when the connection is established.
+
+        Override in your subclass to run setup logic when a client
+        connects.
+        """
+
+    def on_close(self) -> None:
+        """Called when the connection is closed.
+
+        Override in your subclass to run cleanup logic when a client
+        disconnects.
+        """
+
+    def on_error(self, error: Exception) -> None:
+        """Called when a connection error occurs.
+
+        Override to implement custom error handling.
+
+        Args:
+            error: The exception that was raised.
+        """
+        print(f"Channel error: {error}")
+
+    def network_received(self, data: dict[str, Any]) -> None:
+        """Fallback handler for messages with no specific handler.
+
+        Called when a message's ``action`` does not match any
+        ``Network_{action}`` method.  Override to handle unrecognized
+        messages.
+
+        Args:
+            data: The received message dictionary.
+        """
+
+    def _dispatch(self, data: dict[str, Any]) -> None:
+        """Route a message to the matching ``Network_{action}`` method.
+
+        Falls back to :meth:`network_received` when no specific handler
+        is found.
+
+        Args:
+            data: Message dictionary with an ``action`` key.
+        """
+        action = data.get("action", "")
+        method_name = f"Network_{action}"
+        handler = getattr(self, method_name, None)
+        if handler is not None:
+            handler(data)
+        else:
+            self.network_received(data)
+
+    async def _write_loop(self) -> None:
+        """Continuously drain the send queue to the socket."""
+        try:
+            while not self._closed:
+                data = await self._send_queue.get()
+                if not data:
+                    break
+                self._writer.write(data)
+                await self._writer.drain()
+        except Exception:
+            self._closed = True
+
+    async def _read_loop(self) -> None:
+        """Continuously read from the socket and parse messages."""
+        from repod.constants import READ_BUFFER_SIZE
+        from repod.protocol import read_message
+
+        try:
+            while not self._closed:
+                data = await self._reader.read(READ_BUFFER_SIZE)
+                if not data:
+                    break
+
+                self._buffer += data
+                while True:
+                    message, consumed = read_message(self._buffer)
+                    if message is None:
+                        break
+                    self._buffer = self._buffer[consumed:]
+                    if isinstance(message, dict) and "action" in message:
+                        self._receive_queue.put_nowait(message)
+        except Exception:
+            pass
+        finally:
+            await self._handle_close()
+
+    async def _handle_close(self) -> None:
+        """Handle connection teardown and cleanup."""
+        if self._closed:
+            return
+
+        self._closed = True
+        self._receive_queue.put_nowait({"action": "disconnected"})
+        self.on_close()
+
+        # Unblock a pending ``_write_loop`` waiting on the queue.
+        self._send_queue.put_nowait(b"")
+
+        try:
+            self._writer.close()
+            await self._writer.wait_closed()
+        except Exception:
+            pass

repod/client.py

@@ -0,0 +1,276 @@
+"""Async TCP client for connecting to a repod server.
+
+Provides :class:`Client` (low-level) and :class:`ConnectionListener`
+(high-level mixin) for client-side networking.
+
+The client runs an asyncio event loop in a background daemon thread so
+that the main game/application loop can remain fully synchronous.
+
+Example::
+
+    import time
+    from repod import ConnectionListener
+
+
+    class GameClient(ConnectionListener):
+
+        def Network_connected(self, data: dict) -> None:
+            print("Connected!")
+            self.send({"action": "hello", "name": "Alice"})
+
+        def Network_chat(self, data: dict) -> None:
+            print(f"{data['name']}: {data['text']}")
+
+
+    client = GameClient()
+    client.connect("localhost", 5071)
+
+    while True:
+        client.pump()
+        time.sleep(0.01)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import queue
+import socket
+import threading
+from typing import Any
+
+from repod.constants import DEFAULT_HOST, DEFAULT_PORT, READ_BUFFER_SIZE
+from repod.protocol import encode, read_message
+
+
+class Client:
+    """Low-level TCP client with a background asyncio event loop.
+
+    Runs asynchronous read/write loops in a daemon thread and exposes
+    thread-safe :meth:`send` / :meth:`close` methods for use from the
+    main thread.
+
+    Attributes:
+        address: ``(host, port)`` tuple for the remote server.
+    """
+
+    def __init__(
+        self,
+        host: str = DEFAULT_HOST,
+        port: int = DEFAULT_PORT,
+    ) -> None:
+        """Initialize the client.
+
+        Args:
+            host: Server hostname or IP address.
+            port: Server port number.
+        """
+        self.address: tuple[str, int] = (host, port)
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        self._send_queue: queue.Queue[bytes] = queue.Queue()
+        self._receive_queue: queue.Queue[dict[str, Any]] = queue.Queue()
+        self._closed = True
+        self._buffer = b""
+        self._thread: threading.Thread | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def start_background(self) -> None:
+        """Start the network event loop in a daemon thread."""
+        if self._thread is None or not self._thread.is_alive():
+            self._thread = threading.Thread(target=self._run_loop, daemon=True)
+            self._thread.start()
+
+    def send(self, data: dict[str, Any]) -> int:
+        """Queue a message for sending to the server.
+
+        Thread-safe -- call from your main game loop.
+
+        Args:
+            data: Message dictionary.  Should contain an ``action`` key.
+
+        Returns:
+            Number of bytes queued, or ``0`` if disconnected.
+        """
+        if self._closed:
+            return 0
+        outgoing = encode(data)
+        self._send_queue.put(outgoing)
+        return len(outgoing)
+
+    def close(self) -> None:
+        """Close the connection.
+
+        Safe to call from any thread.  Subsequent calls are no-ops.
+        """
+        if self._closed:
+            return
+        self._closed = True
+        self._receive_queue.put({"action": "disconnected"})
+        if self._writer:
+            self._writer.close()
+
+    def _run_loop(self) -> None:
+        """Run the asyncio event loop in the background thread."""
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        try:
+            self._loop.run_until_complete(self._network_task())
+        except Exception as e:
+            print(f"Network thread error: {e}", flush=True)
+        finally:
+            self._loop.close()
+
+    async def _network_task(self) -> None:
+        """Connect and spawn concurrent read/write loops."""
+        try:
+            self._reader, self._writer = await asyncio.open_connection(
+                *self.address,
+            )
+            sock: socket.socket | None = self._writer.get_extra_info("socket")
+            if sock is not None:
+                with contextlib.suppress(OSError):
+                    sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+
+            self._closed = False
+            self._receive_queue.put({"action": "connected"})
+            self._receive_queue.put({"action": "socketConnect"})
+        except Exception as e:
+            self._receive_queue.put({"action": "error", "error": str(e)})
+            return
+
+        await asyncio.gather(self._read_loop(), self._write_loop())
+
+    async def _read_loop(self) -> None:
+        """Read data from the socket and enqueue parsed messages."""
+        try:
+            while not self._closed and self._reader:
+                data = await self._reader.read(READ_BUFFER_SIZE)
+                if not data:
+                    break
+                self._buffer += data
+
+                while True:
+                    message, consumed = read_message(self._buffer)
+                    if message is None:
+                        break
+                    self._buffer = self._buffer[consumed:]
+                    if isinstance(message, dict) and "action" in message:
+                        self._receive_queue.put(message)
+        except Exception:
+            pass
+        finally:
+            self.close()
+
+    async def _write_loop(self) -> None:
+        """Drain the send queue to the socket."""
+        try:
+            while not self._closed and self._writer:
+                if not self._send_queue.empty():
+                    while not self._send_queue.empty():
+                        try:
+                            data = self._send_queue.get_nowait()
+                            self._writer.write(data)
+                        except queue.Empty:
+                            break
+                    await self._writer.drain()
+                await asyncio.sleep(0.005)
+        except Exception:
+            self.close()
+
+
+class ConnectionListener:
+    """High-level mixin for handling server messages synchronously.
+
+    Subclass this and define ``Network_{action}`` methods to handle
+    incoming messages.  Call :meth:`pump` once per frame in your game
+    loop to process queued network events.
+
+    Example::
+
+        class MyClient(ConnectionListener):
+
+            def Network_connected(self, data: dict) -> None:
+                print("Connected to server!")
+
+            def Network_chat(self, data: dict) -> None:
+                print(f"Chat: {data['text']}")
+
+        client = MyClient()
+        client.connect("localhost", 5071)
+
+        while True:
+            client.pump()
+            time.sleep(0.01)
+    """
+
+    _connection: Client | None = None
+
+    def connect(
+        self,
+        host: str = DEFAULT_HOST,
+        port: int = DEFAULT_PORT,
+    ) -> None:
+        """Connect to a remote server.
+
+        Creates a :class:`Client` and starts its background network
+        thread.
+
+        Args:
+            host: Server hostname or IP address.
+            port: Server port number.
+        """
+        self._connection = Client(host, port)
+        self._connection.start_background()
+
+    @property
+    def connection(self) -> Client | None:
+        """The underlying :class:`Client` instance, or ``None``."""
+        return self._connection
+
+    def pump(self) -> None:
+        """Process all pending network messages.
+
+        Call this once per frame in your game loop.  Each queued message
+        is dispatched to the matching ``Network_{action}`` method, or to
+        :meth:`network_received` as a fallback.
+        """
+        if self._connection is None:
+            return
+
+        while not self._connection._receive_queue.empty():
+            try:
+                data = self._connection._receive_queue.get_nowait()
+            except queue.Empty:
+                break
+
+            action = data.get("action", "")
+            method_name = f"Network_{action}"
+            handler = getattr(self, method_name, None)
+            if handler is not None:
+                handler(data)
+            else:
+                self.network_received(data)
+
+    def send(self, data: dict[str, Any]) -> int:
+        """Send a message to the server.
+
+        Args:
+            data: Message dictionary.  Should contain an ``action`` key.
+
+        Returns:
+            Number of bytes queued, or ``0`` if not connected.
+        """
+        if self._connection is None:
+            return 0
+        return self._connection.send(data)
+
+    def network_received(self, data: dict[str, Any]) -> None:
+        """Fallback handler for unrecognized message actions.
+
+        Override to handle messages that don't match any
+        ``Network_{action}`` method.
+
+        Args:
+            data: The received message dictionary.
+        """

repod/constants.py

@@ -0,0 +1,25 @@
+"""Network configuration constants.
+
+Default values used throughout the repod networking library.
+
+Example::
+
+    from repod.constants import DEFAULT_HOST, DEFAULT_PORT
+"""
+
+from typing import Final
+
+DEFAULT_HOST: Final[str] = "127.0.0.1"
+"""Default hostname for connections (localhost)."""
+
+DEFAULT_PORT: Final[int] = 5071
+"""Default port for connections."""
+
+HEADER_SIZE: Final[int] = 4
+"""Size in bytes of the message length header."""
+
+HEADER_FORMAT: Final[str] = ">I"
+"""Struct format for the header (big-endian unsigned int)."""
+
+READ_BUFFER_SIZE: Final[int] = 4096
+"""Buffer size in bytes for reading from sockets."""

repod/protocol.py

@@ -0,0 +1,124 @@
+"""Message serialization protocol.
+
+Handles encoding and decoding of network messages using msgpack
+serialization with length-prefix framing.
+
+Message format::
+
+    ┌──────────────┬────────────────────────┐
+    │ 4 bytes      │ N bytes                │
+    │ length (BE)  │ msgpack payload        │
+    └──────────────┴────────────────────────┘
+
+This framing method is efficient (O(1) boundary detection), safe
+(no delimiter collision risk), and standard (used by Kafka, Redis,
+Protocol Buffers, etc.).
+
+Example::
+
+    >>> from repod.protocol import encode, decode
+    >>> data = {"action": "chat", "message": "Hello!"}
+    >>> encoded = encode(data)
+    >>> decoded = decode(encoded[4:])  # skip the 4-byte header
+    >>> decoded
+    {'action': 'chat', 'message': 'Hello!'}
+"""
+
+from __future__ import annotations
+
+import struct
+from typing import cast
+
+import msgpack
+
+from repod.constants import HEADER_FORMAT, HEADER_SIZE
+
+
+def encode(data: dict) -> bytes:
+    """Encode a dictionary as a length-prefixed message frame.
+
+    The message is serialized with msgpack and prefixed with a 4-byte
+    big-endian length header.
+
+    Args:
+        data: Dictionary containing the message data.  Can include any
+            msgpack-serializable types (dict, list, str, int, float,
+            bool, None).
+
+    Returns:
+        The encoded message with its 4-byte length prefix.
+
+    Raises:
+        TypeError: If *data* contains non-serializable types.
+
+    Example::
+
+        >>> encoded = encode({"action": "ping", "count": 5})
+        >>> len(encoded) > 4  # includes the 4-byte header
+        True
+    """
+    packed = cast(bytes, msgpack.packb(data, use_bin_type=True))
+    length = struct.pack(HEADER_FORMAT, len(packed))
+    return length + packed
+
+
+def decode(data: bytes) -> dict:
+    """Decode msgpack-serialized bytes into a dictionary.
+
+    Note:
+        This expects raw msgpack data, **not** a full length-prefixed
+        frame.  Use :func:`read_message` for stream-based decoding.
+
+    Args:
+        data: Raw msgpack-serialized bytes.
+
+    Returns:
+        The decoded message dictionary.
+
+    Raises:
+        msgpack.UnpackException: If *data* is not valid msgpack.
+
+    Example::
+
+        >>> import msgpack
+        >>> raw = msgpack.packb({"action": "hello"})
+        >>> decode(raw)
+        {'action': 'hello'}
+    """
+    return msgpack.unpackb(data, raw=False)
+
+
+def read_message(stream: bytes) -> tuple[dict | None, int]:
+    """Read a complete message from a byte stream.
+
+    Implements length-prefix framing to extract complete messages from
+    a potentially partial byte buffer.
+
+    Args:
+        stream: Byte buffer that may contain partial or complete
+            messages.
+
+    Returns:
+        A ``(message, bytes_consumed)`` tuple.  If the stream does not
+        yet contain a full message, returns ``(None, 0)``.
+
+    Example::
+
+        >>> frame = encode({"action": "test"})
+        >>> msg, consumed = read_message(frame)
+        >>> msg
+        {'action': 'test'}
+        >>> consumed == len(frame)
+        True
+    """
+    if len(stream) < HEADER_SIZE:
+        return None, 0
+
+    length: int = struct.unpack(HEADER_FORMAT, stream[:HEADER_SIZE])[0]
+    total_size = HEADER_SIZE + length
+
+    if len(stream) < total_size:
+        return None, 0
+
+    payload = stream[HEADER_SIZE:total_size]
+    return msgpack.unpackb(payload, raw=False), total_size

repod/server.py

@@ -0,0 +1,217 @@
+"""Async TCP server for multiplayer games.
+
+The :class:`Server` manages multiple client connections, creating a
+:class:`~repod.channel.Channel` instance for each one.  It can run in
+the main thread or in a background daemon thread for host/client P2P
+setups.
+
+Example::
+
+    class GameChannel(Channel):
+
+        def Network_chat(self, data: dict) -> None:
+            self.server.send_to_all(
+                {"action": "chat", "text": data["text"]}
+            )
+
+
+    class GameServer(Server):
+        channel_class = GameChannel
+
+
+    GameServer(host="0.0.0.0", port=5071).launch()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Any
+
+from repod.channel import Channel
+
+
+class Server[C: Channel]:
+    """Async TCP server that manages client channels.
+
+    Attributes:
+        host: Hostname or IP address the server is bound to.
+        port: Port number the server is listening on.
+        channels: List of currently connected client channels.
+        channel_class: The :class:`Channel` subclass instantiated for
+            each new connection.  Must be set in your subclass.
+    """
+
+    channel_class: type[C]
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 5071,
+    ) -> None:
+        """Initialize the server.
+
+        Args:
+            host: Hostname or IP to bind to.  Use ``"0.0.0.0"`` for all
+                interfaces.
+            port: Port number to listen on.
+        """
+        self.host = host
+        self.port = port
+        self.channels: list[C] = []
+        self._tcp_server: asyncio.Server | None = None
+
+    @property
+    def address(self) -> tuple[str, int]:
+        """Server bind address as a ``(host, port)`` tuple."""
+        return (self.host, self.port)
+
+    async def start(self) -> None:
+        """Start accepting connections.
+
+        Binds to ``host:port`` and begins listening for incoming TCP
+        connections.
+        """
+        self._tcp_server = await asyncio.start_server(
+            self._handle_client,
+            self.host,
+            self.port,
+        )
+        addr = self._tcp_server.sockets[0].getsockname()
+        print(f"Server started on {addr[0]}:{addr[1]}")
+
+    async def run(self) -> None:
+        """Run the server forever.
+
+        Blocks until the server is stopped or the task is cancelled.
+        """
+        await asyncio.Future()
+
+    def launch(self) -> None:
+        """Start the server and block forever.
+
+        Convenience wrapper that hides asyncio boilerplate.  Equivalent
+        to calling :meth:`start` then :meth:`run` inside
+        ``asyncio.run()``.  Handles ``KeyboardInterrupt`` gracefully.
+
+        Example::
+
+            GameServer(host="0.0.0.0", port=5071).launch()
+        """
+
+        async def _main() -> None:
+            await self.start()
+            try:
+                await self.run()
+            except asyncio.CancelledError:
+                pass
+            finally:
+                await self.stop()
+
+        try:
+            asyncio.run(_main())
+        except KeyboardInterrupt:
+            print("\nServer stopped.")
+
+    async def stop(self) -> None:
+        """Stop the server and disconnect all clients."""
+        for channel in self.channels[:]:
+            await channel._handle_close()
+        if self._tcp_server:
+            self._tcp_server.close()
+            await self._tcp_server.wait_closed()
+
+    def start_background(self) -> threading.Thread:
+        """Start the server in a daemon background thread.
+
+        Useful for *Host Game* scenarios where the main thread needs to
+        remain free for the game loop or UI.
+
+        Returns:
+            The :class:`threading.Thread` running the server.
+        """
+        thread = threading.Thread(target=self._run_in_thread, daemon=True)
+        thread.start()
+        return thread
+
+    def on_connect(self, channel: C, addr: tuple[str, int]) -> None:
+        """Called when a new client connects.
+
+        Override to run per-client setup (e.g. add to a player list).
+
+        Args:
+            channel: The newly created channel for this client.
+            addr: ``(host, port)`` of the remote client.
+        """
+
+    def on_disconnect(self, channel: C) -> None:
+        """Called when a client disconnects.
+
+        Override to run per-client cleanup.
+
+        Args:
+            channel: The channel that disconnected.
+        """
+
+    def send_to_all(self, data: dict[str, Any]) -> None:
+        """Broadcast a message to every connected client.
+
+        Args:
+            data: Message dictionary to send to all channels.
+        """
+        for channel in self.channels:
+            channel.send(data)
+
+    def _run_in_thread(self) -> None:
+        """Create a new event loop and run the server inside it."""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(self.start())
+        try:
+            loop.run_until_complete(self.run())
+        except Exception as e:
+            print(f"Background server error: {e}")
+        finally:
+            loop.run_until_complete(self.stop())
+            loop.close()
+
+    async def _handle_client(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+    ) -> None:
+        """Handle a newly connected client."""
+        channel = self.channel_class(reader, writer, server=self)
+        self.channels.append(channel)
+
+        channel.send({"action": "connected"})
+        channel.on_connect()
+        self.on_connect(channel, writer.get_extra_info("peername"))
+
+        try:
+            await asyncio.gather(
+                channel._read_loop(),
+                channel._write_loop(),
+                self._process_loop(channel),
+            )
+        except Exception as e:
+            channel.on_error(e)
+        finally:
+            await self._remove_channel(channel)
+
+    async def _process_loop(self, channel: C) -> None:
+        """Drain the channel's receive queue and dispatch messages."""
+        try:
+            while not channel._closed:
+                data = await channel._receive_queue.get()
+                if data.get("action") == "disconnected":
+                    break
+                channel._dispatch(data)
+        except Exception:
+            pass
+
+    async def _remove_channel(self, channel: C) -> None:
+        """Remove a channel and notify via :meth:`on_disconnect`."""
+        if channel in self.channels:
+            self.channels.remove(channel)
+        self.on_disconnect(channel)

repodnet-0.1.0.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: repodnet
+Version: 0.1.0
+Summary: Modern async networking library for multiplayer games
+Project-URL: Homepage, https://github.com/Walkercito/repod
+Project-URL: Repository, https://github.com/Walkercito/repod
+Project-URL: Documentation, https://github.com/Walkercito/repod/blob/main/docs/DOCS.md
+Project-URL: Issues, https://github.com/Walkercito/repod/issues
+Author-email: Walkercito <walekrcitoliver@gmail.com>
+License-Expression: LGPL-3.0-or-later
+License-File: COPYING
+Keywords: async,gamedev,msgpack,multiplayer,networking
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: msgpack>=1.0.0
+Description-Content-Type: text/markdown
+
+# repod -- multiplayer networking library for Python games
+
+[![Python 3.12+](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FWalkercito%2Frepod%2Fmain%2Fpyproject.toml&logo=python&logoColor=white&label=Python)](https://www.python.org/)
+[![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![msgpack](https://img.shields.io/badge/serialization-msgpack-orange)](https://msgpack.org/)
+[![asyncio](https://img.shields.io/badge/I%2FO-asyncio-purple)](https://docs.python.org/3/library/asyncio.html)
+
+repod is a networking library designed to make it easy to write multiplayer games in Python. It uses `asyncio` and `msgpack` to asynchronously serialize network events and arbitrary data structures, and delivers them to your high-level classes through simple callback methods.
+
+It is a modernized fork of [PodSixNet](https://github.com/chr15m/PodSixNet). Same ideas -- channels, action-based message dispatch, synchronous pump loops -- but rebuilt from scratch for Python 3.12+ with async I/O, binary msgpack serialization, and full type annotations. PodSixNet was built on `asyncore`, which was removed in Python 3.12; repod is the drop-in replacement.
+
+Each class within your game client which wants to receive network events subclasses `ConnectionListener` and implements `Network_*` methods to catch specific events from the server. You don't have to wait for buffers to fill, or check sockets for waiting data or anything like that -- just call `client.pump()` once per game loop and the library handles everything else, passing off events to your listener. Sending data back to the server is just as easy with `client.send(mydata)`. On the server side, events are propagated to `Network_*` callbacks on your `Channel` subclass, and data is sent back to clients with `channel.send(mydata)`.
+
+## Install
+
+```bash
+pip install repod
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add repod
+```
+
+## Examples
+
+Chat example:
+
+- `python examples/chat_server.py`
+- and a couple of instances of `python examples/chat_client.py`
+
+Whiteboard example (requires pygame-ce):
+
+- `python examples/whiteboard_server.py`
+- and a couple of instances of `python examples/whiteboard_client.py`
+
+LagTime example (measures round-trip time from server to client):
+
+- `python examples/lag_time_server.py`
+- and a couple of instances of `python examples/lag_time_client.py`
+
+## Quick start -- Server
+
+You need to subclass two classes to make your own server. Each time a client connects, a new `Channel` instance is created, so you subclass `Channel` to make your server-side representation of a client:
+
+```python
+from repod import Channel
+
+class ClientChannel(Channel):
+
+    def network_received(self, data: dict) -> None:
+        print(data)
+
+    def Network_myaction(self, data: dict) -> None:
+        print("myaction:", data)
+```
+
+Whenever the client sends data, the `network_received()` fallback is called if no specific handler exists. The method `Network_myaction()` is only called if your data has an `"action"` key with a value of `"myaction"`. In other words, if the data looks like:
+
+```python
+{"action": "myaction", "blah": 123, ...}
+```
+
+Next, subclass `Server`:
+
+```python
+from repod import Server
+
+class MyServer(Server):
+    channel_class = ClientChannel
+
+    def on_connect(self, channel, addr):
+        print("new connection:", channel)
+```
+
+Set `channel_class` to the Channel subclass you created above. The `on_connect()` method is called whenever a new client connects.
+
+To run the server, call `launch()`:
+
+```python
+MyServer(host="0.0.0.0", port=5071).launch()
+```
+
+That's it. One line. `launch()` handles the event loop internally and catches `Ctrl+C` for clean shutdown.
+
+When you want to send data to a specific client, use the `send` method on the Channel:
+
+```python
+channel.send({"action": "hello", "message": "hello client!"})
+```
+
+## Quick start -- Client
+
+To connect to your server, subclass `ConnectionListener`:
+
+```python
+import time
+from repod import ConnectionListener
+
+class MyClient(ConnectionListener):
+
+    def Network_connected(self, data: dict) -> None:
+        print("connected to the server")
+
+    def Network_error(self, data: dict) -> None:
+        print("error:", data["error"])
+
+    def Network_disconnected(self, data: dict) -> None:
+        print("disconnected from the server")
+
+    def Network_myaction(self, data: dict) -> None:
+        print("myaction:", data)
+```
+
+Network events are received by `Network_*` callback methods. Replace `*` with the value of the `"action"` key you want to catch. The `connected`, `disconnected`, and `error` events are sent automatically by repod.
+
+Connect and pump:
+
+```python
+client = MyClient()
+client.connect("localhost", 5071)
+
+while True:
+    client.pump()
+    time.sleep(0.01)
+```
+
+Call `pump()` once per game loop and repod handles everything -- reading from the socket, deserializing, and dispatching to your `Network_*` methods. Sending data to the server:
+
+```python
+client.send({"action": "myaction", "blah": 123, "things": [3, 4, 3, 4, 7]})
+```
+
+This works with any game framework that has a main loop: pygame, raylib, arcade, pyglet, etc. Just drop `pump()` into the loop.
+
+## Documentation
+
+Full tutorial and API reference: **[docs/DOCS.md](docs/DOCS.md)**
+
+## Why not PodSixNet?
+
+PodSixNet was great for its time, but:
+
+- It's built on `asyncore`, which was **removed in Python 3.12**
+- It uses `rencode` / custom delimiter-based framing (`\0---\0`), which is fragile with binary data
+- It has no type annotations, no modern tooling support
+- It is no longer maintained ([chr15m/PodSixNet#46](https://github.com/chr15m/PodSixNet/issues/46))
+
+repod keeps the same simple API philosophy but replaces the internals:
+
+- **asyncio** instead of asyncore
+- **msgpack** with length-prefix framing instead of rencode with delimiter framing
+- **Full type annotations** with PEP 695 generics (optional)
+- **Python 3.12+** only -- no compatibility shims
+
+## Development
+
+```bash
+uv sync --group dev
+uv run ruff check .
+uv run ruff format --check .
+uv run ty check
+uv run pytest tests/ -v
+```
+
+## License
+
+Copyright Walker Gonzales, 2025.
+
+repod is licensed under the terms of the **LGPL v3.0** or later. See the [COPYING](COPYING) file for details.
+
+This is the same license as [PodSixNet](https://github.com/chr15m/PodSixNet), from which repod is forked. In short: you can use repod in any project (commercial or otherwise), but if you modify the repod library code itself, you must make the modified source available.

repodnet-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+repod/__init__.py,sha256=3v-9I_VA5CTYebbqMQD2paMmMmkvS3IOuux0W87vIVA,1374
+repod/channel.py,sha256=eEIVhJdqfhD7RPjTOlFihytTS6GvpRwlmRLHL9y1zbE,6749
+repod/client.py,sha256=5eL9omBiXn7zmis-hk7K-LQg6BpRpen2fhV6atP34O0,8701
+repod/constants.py,sha256=kP2Ig7eRBlez_1_eYrMcdGREocSaJ36RuEnHfSJK2_k,625
+repod/protocol.py,sha256=Y764G3vyynKdGFl1xJ8AZlc8UIH3vBwrrz2-IGo-UJY,3562
+repod/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+repod/server.py,sha256=qFBC7eKPkKZN0fszze8W3VRr1kjPvFtFIXldnL11Ltk,6530
+repodnet-0.1.0.dist-info/METADATA,sha256=w8WeHYW14gXE6QIYYRace0slQzaYqBWGOXdD9fljjQA,8021
+repodnet-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+repodnet-0.1.0.dist-info/licenses/COPYING,sha256=qFPC_-wXBXhyNA7uJCrk2Wy_K1IK4n2QPhsv7xpfnRw,7639
+repodnet-0.1.0.dist-info/RECORD,,

repodnet-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

repodnet-0.1.0.dist-info/licenses/COPYING

@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.