konet 0.1.3__tar.gz

konet-0.1.3/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: konet
+Version: 0.1.3
+Summary: Python SDK for Konet realtime infrastructure
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# konet (Python SDK)
+
+Async Python SDK for [Konet](https://github.com/raucheacho/konet), the
+self-hosted realtime engine (channels, presence, broadcast).
+
+## Install
+
+```bash
+pip install konet
+```
+
+## Usage
+
+```python
+import asyncio
+from konet import KonetClient
+
+async def main():
+    async with KonetClient("ws://localhost:4000/socket", token="<your-token>") as client:
+        channel = client.channel("room:lobby")
+        await channel.subscribe()
+        channel.on("message", lambda payload: print(payload))
+        await channel.send("message", {"text": "Hello!"})
+        await asyncio.sleep(60)
+
+asyncio.run(main())
+```
+
+## License
+
+MIT

konet-0.1.3/README.md

@@ -0,0 +1,31 @@
+# konet (Python SDK)
+
+Async Python SDK for [Konet](https://github.com/raucheacho/konet), the
+self-hosted realtime engine (channels, presence, broadcast).
+
+## Install
+
+```bash
+pip install konet
+```
+
+## Usage
+
+```python
+import asyncio
+from konet import KonetClient
+
+async def main():
+    async with KonetClient("ws://localhost:4000/socket", token="<your-token>") as client:
+        channel = client.channel("room:lobby")
+        await channel.subscribe()
+        channel.on("message", lambda payload: print(payload))
+        await channel.send("message", {"text": "Hello!"})
+        await asyncio.sleep(60)
+
+asyncio.run(main())
+```
+
+## License
+
+MIT

konet-0.1.3/konet/__init__.py

@@ -0,0 +1,25 @@
+"""
+konet — Python SDK for Konet realtime infrastructure.
+
+Quick start::
+
+    import asyncio
+    from konet import KonetClient
+
+    async def main():
+        async with KonetClient("ws://localhost:4000/socket", token="kt_anon_...") as client:
+            channel = client.channel("room:lobby")
+            await channel.subscribe()
+
+            channel.on("message", lambda p: print("received:", p))
+            await channel.send("message", {"text": "Hello from Python!"})
+            await asyncio.sleep(60)
+
+    asyncio.run(main())
+"""
+
+from .client import KonetClient
+from .channel import Channel
+
+__all__ = ["KonetClient", "Channel"]
+__version__ = "0.1.0"

konet-0.1.3/konet/channel.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from collections import defaultdict
+from typing import Any, Callable, Awaitable
+
+EventHandler = Callable[[Any], Awaitable[None] | None]
+
+
+class Channel:
+    def __init__(
+        self,
+        topic: str,
+        send_fn: Callable,
+        next_ref: Callable[[], str],
+    ) -> None:
+        self.topic = topic
+        self._state: str = "idle"  # idle | joining | joined | errored
+        self._send_fn = send_fn
+        self._next_ref = next_ref
+        self._join_ref: str | None = None
+        self._handlers: dict[str, list[EventHandler]] = defaultdict(list)
+        self._reply_futures: dict[str, asyncio.Future] = {}
+
+    async def subscribe(self) -> None:
+        if self._state in ("joined", "joining"):
+            return
+
+        self._state = "joining"
+        ref = self._next_ref()
+        self._join_ref = ref
+
+        loop = asyncio.get_event_loop()
+        fut: asyncio.Future = loop.create_future()
+        self._reply_futures[ref] = fut
+
+        await self._send_fn([ref, ref, self.topic, "phx_join", {}])
+
+        reply = await asyncio.wait_for(fut, timeout=10.0)
+        if reply.get("status") == "ok":
+            self._state = "joined"
+        else:
+            self._state = "errored"
+            raise RuntimeError(f"Failed to join {self.topic}: {reply.get('response')}")
+
+    async def unsubscribe(self) -> None:
+        if self._state != "joined":
+            return
+        ref = self._next_ref()
+        self._state = "idle"
+        await self._send_fn([self._join_ref, ref, self.topic, "phx_leave", {}])
+        self._join_ref = None
+
+    def on(self, event: str, handler: EventHandler) -> Callable[[], None]:
+        """Register an event handler. Returns an unsubscribe callable."""
+        self._handlers[event].append(handler)
+
+        def off() -> None:
+            self._handlers[event].remove(handler)
+
+        return off
+
+    async def send(self, event: str, payload: Any = None) -> None:
+        if self._state != "joined":
+            raise RuntimeError(f"Channel {self.topic} is not joined")
+
+        ref = self._next_ref()
+        await self._send_fn(
+            [self._join_ref, ref, self.topic, "broadcast", {"event": event, "payload": payload or {}}]
+        )
+
+    def _receive(self, frame: list) -> None:
+        """Called by the client when a message arrives for this topic."""
+        _join_ref, ref, _topic, event, payload = frame
+
+        if event == "phx_reply":
+            fut = self._reply_futures.pop(ref, None)
+            if fut and not fut.done():
+                fut.set_result(payload if isinstance(payload, dict) else {})
+            return
+
+        for handler in list(self._handlers.get(event, [])):
+            result = handler(payload)
+            if asyncio.iscoroutine(result):
+                asyncio.create_task(result)

konet-0.1.3/konet/client.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+from typing import Any
+from urllib.parse import urlencode
+
+import websockets
+from websockets.exceptions import ConnectionClosed, WebSocketException
+
+from .channel import Channel
+
+
+class KonetClient:
+    """
+    Async Konet client.
+
+    Usage::
+
+        async with KonetClient("ws://localhost:4000/socket", token="kt_anon_...") as client:
+            channel = client.channel("room:lobby")
+            await channel.subscribe()
+            channel.on("message", lambda p: print(p))
+            await channel.send("message", {"text": "Hello!"})
+            await asyncio.sleep(60)
+    """
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        token: str,
+        heartbeat_interval: float = 30.0,
+        reconnect_delay: float = 1.0,
+        max_reconnect_tries: int = 10,
+    ) -> None:
+        self._url = url
+        self._token = token
+        self._heartbeat_interval = heartbeat_interval
+        self._reconnect_delay = reconnect_delay
+        self._max_reconnect_tries = max_reconnect_tries
+
+        self._ws: websockets.ClientConnection | None = None
+        self._channels: dict[str, Channel] = {}
+        self._ref_counter = 0
+        self._connected = False
+        self._tasks: list[asyncio.Task] = []
+
+    async def __aenter__(self) -> "KonetClient":
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *_: Any) -> None:
+        await self.disconnect()
+
+    def _websocket_url(self) -> str:
+        # Phoenix mounts the actual websocket transport at "<socket path>/websocket",
+        # not at the socket path itself (e.g. "/socket" -> "/socket/websocket").
+        base = self._url.rstrip("/")
+        params = urlencode({"token": self._token, "vsn": "2.0.0"})
+        return f"{base}/websocket?{params}"
+
+    async def connect(self) -> None:
+        self._ws = await websockets.connect(self._websocket_url())
+        self._connected = True
+
+        self._tasks = [
+            asyncio.create_task(self._read_loop()),
+            asyncio.create_task(self._heartbeat_loop()),
+        ]
+
+    async def disconnect(self) -> None:
+        self._connected = False
+        for task in self._tasks:
+            task.cancel()
+        if self._ws:
+            await self._ws.close()
+            self._ws = None
+
+    def channel(self, topic: str) -> Channel:
+        if topic not in self._channels:
+            self._channels[topic] = Channel(topic, self._send, self._next_ref)
+        return self._channels[topic]
+
+    async def _send(self, frame: list) -> None:
+        if self._ws is None:
+            raise RuntimeError("Not connected")
+        await self._ws.send(json.dumps(frame))
+
+    def _next_ref(self) -> str:
+        self._ref_counter += 1
+        return str(self._ref_counter)
+
+    async def _read_loop(self) -> None:
+        reconnect_attempts = 0
+        while self._connected:
+            try:
+                if self._ws is None:
+                    await asyncio.sleep(0.1)
+                    continue
+
+                raw = await self._ws.recv()
+                frame = json.loads(raw)
+
+                if not isinstance(frame, list) or len(frame) != 5:
+                    continue
+
+                _join_ref, _ref, topic, event, _payload = frame
+
+                if topic == "phoenix":
+                    continue
+
+                ch = self._channels.get(topic)
+                if ch:
+                    ch._receive(frame)
+
+                reconnect_attempts = 0
+
+            except ConnectionClosed:
+                if not self._connected:
+                    break
+                if reconnect_attempts >= self._max_reconnect_tries:
+                    break
+                delay = min(self._reconnect_delay * (2 ** reconnect_attempts), 30.0)
+                reconnect_attempts += 1
+                await asyncio.sleep(delay)
+                await self._reconnect()
+
+            except asyncio.CancelledError:
+                break
+
+    async def _heartbeat_loop(self) -> None:
+        while self._connected:
+            try:
+                await asyncio.sleep(self._heartbeat_interval)
+                ref = self._next_ref()
+                await self._send([None, ref, "phoenix", "heartbeat", {}])
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                pass
+
+    async def _reconnect(self) -> None:
+        try:
+            self._ws = await websockets.connect(self._websocket_url())
+        except Exception:
+            self._ws = None

konet-0.1.3/konet.egg-info/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: konet
+Version: 0.1.3
+Summary: Python SDK for Konet realtime infrastructure
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# konet (Python SDK)
+
+Async Python SDK for [Konet](https://github.com/raucheacho/konet), the
+self-hosted realtime engine (channels, presence, broadcast).
+
+## Install
+
+```bash
+pip install konet
+```
+
+## Usage
+
+```python
+import asyncio
+from konet import KonetClient
+
+async def main():
+    async with KonetClient("ws://localhost:4000/socket", token="<your-token>") as client:
+        channel = client.channel("room:lobby")
+        await channel.subscribe()
+        channel.on("message", lambda payload: print(payload))
+        await channel.send("message", {"text": "Hello!"})
+        await asyncio.sleep(60)
+
+asyncio.run(main())
+```
+
+## License
+
+MIT

konet-0.1.3/konet.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+konet/__init__.py
+konet/channel.py
+konet/client.py
+konet.egg-info/PKG-INFO
+konet.egg-info/SOURCES.txt
+konet.egg-info/dependency_links.txt
+konet.egg-info/requires.txt
+konet.egg-info/top_level.txt

konet-0.1.3/konet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

konet-0.1.3/konet.egg-info/requires.txt

@@ -0,0 +1,5 @@
+websockets>=12.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23

konet-0.1.3/konet.egg-info/top_level.txt

@@ -0,0 +1 @@
+konet

konet-0.1.3/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "konet"
+version = "0.1.3"
+description = "Python SDK for Konet realtime infrastructure"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = [
+    "websockets>=12.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["konet*"]

konet-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+