Client-Server Model

from repod import Server, Channel

class GameChannel(Channel):
    def Network_chat(self, data: dict) -> None:
        self.server.send_to_all(data)

class GameServer(Server):
    channel_class = GameChannel

GameServer(host="0.0.0.0", port=5071).launch()

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.
    """

    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:
        log.info("server_stopped")

async def _handle_client(
    self,
    reader: asyncio.StreamReader,
    writer: asyncio.StreamWriter,
) -> None:
    """Handle a newly connected client."""
    # 1. Create the channel instance
    channel = self.channel_class(reader, writer, server=self)
    self.channels.append(channel)
    addr = writer.get_extra_info("peername")

    log.info(
        "client_connected",
        addr=f"{addr[0]}:{addr[1]}",
        clients=len(self.channels),
    )

    # 2. Send initial connected message
    channel.send({"action": "connected"})
    
    # 3. Call lifecycle hooks
    channel.on_connect()
    self.on_connect(channel, addr)

    # 4. Run the channel's read/write/process loops
    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)

class GameChannel(Channel):
    def Network_chat(self, data: dict) -> None:
        print(f"Message from {self.addr[0]}:{self.addr[1]}")
        
        # Broadcast to all OTHER clients
        for channel in self.server.channels:
            if channel != self:
                channel.send(data)

class GameChannel(Channel):
    def on_connect(self) -> None:
        # Per-client setup
        self.player_id = generate_id()
        self.send({"action": "welcome", "id": self.player_id})

class GameChannel(Channel):
    def on_close(self) -> None:
        # Per-client cleanup
        print(f"Client {self.addr} disconnected")

class GameChannel(Channel):
    def on_error(self, error: Exception) -> None:
        print(f"Channel error: {error}")
        # Custom error handling

from repod import Client

client = Client(host="localhost", port=5071)
client.start_background()

# Send messages from main thread
client.send({"action": "hello"})

# Poll for received messages
while not client._receive_queue.empty():
    message = client._receive_queue.get()
    print(message)

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()

import time
from repod import ConnectionListener

class GameClient(ConnectionListener):
    def Network_connected(self, data: dict) -> None:
        print("Connected!")
        self.send({"action": "hello"})
    
    def Network_chat(self, data: dict) -> None:
        print(f"Chat: {data['text']}")

client = GameClient()
client.connect("localhost", 5071)

while True:
    client.pump()  # Process queued messages
    time.sleep(0.01)

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.
    """
    log.info("connecting", host=host, port=port)
    self._connection = Client(host, port)
    self._connection.start_background()

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:
            log.debug("message_dispatched", action=action)
            handler(data)
        else:
            log.debug("message_unhandled", action=action)
            self.network_received(data)

from repod import Server, Channel, ConnectionListener
import time

class GameChannel(Channel):
    def Network_move(self, data: dict) -> None:
        self.server.send_to_all(data)

class GameServer(Server):
    channel_class = GameChannel

class GameClient(ConnectionListener):
    def Network_move(self, data: dict) -> None:
        print(f"Player moved: {data}")

# Start server in background
server = GameServer(host="127.0.0.1", port=5071)
server_thread = server.start_background()

# Connect as a client in main thread
client = GameClient()
client.connect("127.0.0.1", 5071)

# Game loop
while True:
    client.pump()
    # Your game logic here
    time.sleep(0.01)

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 exc:
        log.error("background_server_error", error=str(exc))
    finally:
        loop.run_until_complete(self.stop())
        loop.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 exc:
        log.error("network_thread_error", error=str(exc))
    finally:
        self._loop.close()

# 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)