xconn 0.1.0__tar.gz

xconn-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 XConnIO
+Copyright (c) 2024 Simple Things Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xconn-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.1
+Name: xconn
+Version: 0.1.0
+Summary: https://github.com/xconnio/xconn-python
+Author-email: Omer Akram <omer@thing.com>, Mahad Munir <mahad@xconn.io>
+License: MIT License
+        
+        Copyright (c) 2024 XConnIO
+        Copyright (c) 2024 Simple Things Inc.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/xconnio/xconn-python
+Project-URL: Bug Tracker, https://github.com/xconnio/xconn-python/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websockets
+Requires-Dist: wampproto
+Requires-Dist: aiohttp
+Requires-Dist: uvloop
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: ruff; extra == "test"
+
+# XConn Python

xconn-0.1.0/README.md

@@ -0,0 +1 @@
+# XConn Python

xconn-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xconn"
+version = "0.1.0"
+authors = [
+  {name="Omer Akram", email="omer@thing.com"},
+  {name="Mahad Munir", email="mahad@xconn.io"},
+]
+description = "https://github.com/xconnio/xconn-python"
+readme = "README.md"
+license = {file = "LICENSE"}
+dependencies = [
+  "websockets",
+  "wampproto",
+  "aiohttp",
+  "uvloop",
+]
+requires-python = ">=3.10"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+
+[project.optional-dependencies]
+test = [
+  "coverage",
+  "pytest",
+  "pytest-asyncio",
+  "ruff",
+]
+
+[project.scripts]
+"xconn" = "xconn.__main__:main"
+
+[project.urls]
+"Homepage" = "https://github.com/xconnio/xconn-python"
+"Bug Tracker" = "https://github.com/xconnio/xconn-python/issues"

xconn-0.1.0/setup.cfg

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

xconn-0.1.0/xconn/__main__.py

@@ -0,0 +1,68 @@
+import asyncio
+import argparse
+import importlib
+import sys
+
+import uvloop
+from wampproto.serializers import CBORSerializer
+
+from xconn.app import WampApp
+from xconn.router import Router
+from xconn.server import Server
+from xconn.session import AsyncSession
+from xconn.types import ServerSideLocalBaseSession, ClientSideLocalBaseSession
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8080)
+    parser.add_argument("--host", type=str, default="127.0.0.1")
+    parser.add_argument("--realm", type=str, default="realm1")
+    parser.add_argument("--directory", type=str, default=".")
+    parser.add_argument("APP")
+
+    parsed = parser.parse_args()
+
+    split = parsed.APP.split(":")
+    if len(split) != 2:
+        raise RuntimeError("invalid app argument, must be of format: module:instance")
+
+    # TODO: find a better, reliable way
+    sys.path.append(parsed.directory)
+    module = importlib.import_module(split[0])
+    app: WampApp = getattr(module, split[1])
+    if not isinstance(app, WampApp):
+        raise RuntimeError(f"app instance is of unknown type {type(app)}")
+
+    # uvloop makes things fast.
+    uvloop.install()
+
+    router = Router()
+    router.add_realm(parsed.realm)
+
+    serializer = CBORSerializer()
+    client_side_base = ClientSideLocalBaseSession(1, parsed.realm, "local", "local", serializer, router)
+    server_side_base = ServerSideLocalBaseSession(1, parsed.realm, "local", "local", serializer)
+    server_side_base.set_other(client_side_base)
+
+    router.attach_client(server_side_base)
+
+    async def setup():
+        session = AsyncSession(client_side_base)
+        for procedure, handler in app.procedures.items():
+            await session.register(procedure, handler)
+            print(f"registered procedure {procedure}")
+
+        server = Server(router)
+        await server.start(parsed.host, parsed.port, start_loop=False)
+        print(f"Listening for websocket connections on ws://{parsed.host}:{parsed.port}/ws")
+        await asyncio.Event().wait()
+
+    try:
+        asyncio.run(setup())
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

xconn-0.1.0/xconn/acceptor.py

@@ -0,0 +1,51 @@
+import socket
+from typing import Sequence
+
+from aiohttp import web
+from wampproto import auth, acceptor
+from websockets import ServerProtocol
+from websockets.sync.server import ServerConnection, Subprotocol
+
+from xconn import types, helpers
+
+
+class WebsocketsAcceptor:
+    WSProtocols: Sequence[Subprotocol] = [
+        Subprotocol("wamp.2.json"),
+        Subprotocol("wamp.2.cbor"),
+        Subprotocol("wamp.2.msgpack"),
+    ]
+
+    def __init__(self, authenticator: auth.IServerAuthenticator = None) -> None:
+        self.authenticator = authenticator
+        self.subprotocols = WebsocketsAcceptor.WSProtocols
+
+    def accept(self, conn: socket.socket) -> types.BaseSession:
+        ws = ServerConnection(conn, ServerProtocol(subprotocols=WebsocketsAcceptor.WSProtocols))
+        ws.handshake()
+
+        serializer = helpers.get_serializer(ws.subprotocol)
+        a = acceptor.Acceptor(serializer=serializer, authenticator=self.authenticator)
+
+        while True:
+            data = ws.recv()
+            to_send, is_final = a.receive(data)
+            ws.send(to_send)
+            if is_final:
+                return types.BaseSession(ws, a.get_session_details(), serializer)
+
+
+class AIOHttpAcceptor:
+    def __init__(self, authenticator: auth.IServerAuthenticator = None) -> None:
+        self.authenticator = authenticator
+
+    async def accept(self, ws: web.WebSocketResponse) -> types.AIOHttpBaseSession:
+        serializer = helpers.get_serializer(ws.ws_protocol)
+        a = acceptor.Acceptor(serializer=serializer, authenticator=self.authenticator)
+
+        while not ws.closed:
+            msg = await ws.receive()
+            to_send, is_final = a.receive(msg.data)
+            await ws.send_bytes(to_send)
+            if is_final:
+                return types.AIOHttpBaseSession(ws, a.get_session_details(), serializer)

xconn-0.1.0/xconn/app.py

@@ -0,0 +1,29 @@
+from typing import Callable
+
+
+class IApp:
+    @property
+    def procedures(self) -> dict[str, Callable]:
+        raise NotImplementedError()
+
+    def register(self, procedure: str):
+        raise NotImplementedError()
+
+
+class WampApp(IApp):
+    def __init__(self):
+        super().__init__()
+        self._procedures = {}
+
+    @property
+    def procedures(self) -> dict[str, Callable]:
+        return self._procedures
+
+    def register(self, procedure: str):
+        def _register(func):
+            if procedure in self._procedures:
+                raise ValueError(f"procedure {procedure} already registered")
+
+            self._procedures[procedure] = func
+
+        return _register

xconn-0.1.0/xconn/client.py

@@ -0,0 +1,20 @@
+from wampproto import auth, serializers
+
+from xconn.joiner import WebsocketsJoiner
+from xconn.session import Session
+
+
+class Client:
+    def __init__(
+        self,
+        authenticator: auth.IClientAuthenticator,
+        serializer: serializers.Serializer = serializers.JSONSerializer(),
+    ):
+        self._authenticator = authenticator
+        self._serializer = serializer
+
+    def connect(self, url: str, realm: str) -> Session:
+        j = WebsocketsJoiner(self._authenticator, self._serializer)
+        details = j.join(url, realm)
+
+        return Session(details)

xconn-0.1.0/xconn/helpers.py

@@ -0,0 +1,27 @@
+from wampproto import serializers
+
+JSON_SUBPROTOCOL = "wamp.2.json"
+CBOR_SUBPROTOCOL = "wamp.2.cbor"
+MSGPACK_SUBPROTOCOL = "wamp.2.msgpack"
+
+
+def get_ws_subprotocol(serializer: serializers.Serializer):
+    if isinstance(serializer, serializers.JSONSerializer):
+        return JSON_SUBPROTOCOL
+    elif isinstance(serializer, serializers.CBORSerializer):
+        return CBOR_SUBPROTOCOL
+    elif isinstance(serializer, serializers.MsgPackSerializer):
+        return MSGPACK_SUBPROTOCOL
+    else:
+        raise ValueError("invalid serializer")
+
+
+def get_serializer(ws_subprotocol: str) -> serializers.Serializer:
+    if ws_subprotocol == JSON_SUBPROTOCOL:
+        return serializers.JSONSerializer()
+    elif ws_subprotocol == CBOR_SUBPROTOCOL:
+        return serializers.CBORSerializer()
+    elif ws_subprotocol == MSGPACK_SUBPROTOCOL:
+        return serializers.MsgPackSerializer()
+    else:
+        raise ValueError(f"invalid websocket subprotocol {ws_subprotocol}")

xconn-0.1.0/xconn/joiner.py

@@ -0,0 +1,29 @@
+from websockets.sync.client import connect
+from wampproto import joiner, serializers, auth
+from wampproto.joiner import Joiner
+
+from xconn import types, helpers
+
+
+class WebsocketsJoiner:
+    def __init__(
+        self,
+        authenticator: auth.IClientAuthenticator = None,
+        serializer: serializers.Serializer = serializers.JSONSerializer(),
+    ):
+        self._authenticator = authenticator
+        self._serializer = serializer
+
+    def join(self, uri: str, realm: str) -> types.BaseSession:
+        ws = connect(uri, subprotocols=[helpers.get_ws_subprotocol(serializer=self._serializer)])
+
+        j: Joiner = joiner.Joiner(realm, serializer=self._serializer, authenticator=self._authenticator)
+        ws.send(j.send_hello())
+
+        while True:
+            data = ws.recv()
+            to_send = j.receive(data)
+            if to_send is None:
+                return types.BaseSession(ws, j.get_session_details(), self._serializer)
+
+            ws.send(to_send)

xconn-0.1.0/xconn/realm.py

@@ -0,0 +1,75 @@
+from asyncio import gather
+
+from wampproto.types import MessageWithRecipient
+from wampproto import dealer, broker, messages
+
+from xconn import types
+
+
+class Realm:
+    def __init__(self):
+        super().__init__()
+        self.dealer = dealer.Dealer()
+        self.broker = broker.Broker()
+
+        self.clients: dict[int, types.IAsyncBaseSession] = {}
+
+    def attach_client(self, base: types.IAsyncBaseSession):
+        self.clients[base.id] = base
+        self.dealer.add_session(base.id)
+        self.broker.add_session(base.id)
+
+    def detach_client(self, base: types.IAsyncBaseSession):
+        del self.clients[base.id]
+        self.broker.remove_session(base.id)
+        self.dealer.remove_session(base.id)
+
+    def stop(self):
+        """stop will disconnect all clients."""
+        pass
+
+    async def receive_message(self, session_id: int, msg: messages.Message):
+        match msg.TYPE:
+            case messages.Call.TYPE | messages.Yield.TYPE | messages.Register.TYPE | messages.UnRegister.TYPE:
+                recipient = self.dealer.receive_message(session_id, msg)
+                client = self.clients[recipient.recipient]
+                await client.send_message(recipient.message)
+
+            case messages.Publish.TYPE:
+                recipients = self.broker.receive_message(session_id, msg)
+                if recipients is None:
+                    # no subscribers AND "acknowledge=False"
+                    return
+
+                # if the publish options had "acknowledge=True" the last one
+                # should be PUBLISHED.
+                published: MessageWithRecipient | None = None
+                if isinstance(recipients[-1].message, messages.Published):
+                    published = recipients.pop(-1)
+
+                tasks = []
+                for recipient in recipients:
+                    client = self.clients[recipient.recipient]
+                    tasks.append(client.send_message(recipient.message))
+
+                await gather(*tasks)
+
+                if published is not None:
+                    client = self.clients[published.recipient]
+                    await client.send_message(published.message)
+
+            case messages.Subscribe.TYPE | messages.UnSubscribe.TYPE:
+                recipients = self.broker.receive_message(session_id, msg)
+                recipient = recipients[0]
+
+                client = self.clients[recipient.recipient]
+                await client.send_message(recipient.message)
+            case messages.Goodbye.TYPE:
+                self.dealer.remove_session(session_id)
+                self.broker.remove_session(session_id)
+                try:
+                    client = self.clients.pop(session_id)
+                except KeyError:
+                    return
+
+                await client.close()

xconn-0.1.0/xconn/router.py

@@ -0,0 +1,36 @@
+from wampproto import messages
+
+from xconn import realm, types
+
+
+class Router:
+    def __init__(self):
+        super().__init__()
+        self.realms: dict[str, realm.Realm] = {}
+
+    def add_realm(self, name: str):
+        self.realms[name] = realm.Realm()
+
+    def remove_realm(self, name: str):
+        del self.realms[name]
+
+    def has_realm(self, name: str):
+        return name in self.realms
+
+    def attach_client(self, base_session: types.IAsyncBaseSession):
+        if base_session.realm not in self.realms:
+            raise ValueError(f"cannot attach client to non-existent realm {base_session.realm}")
+
+        self.realms[base_session.realm].attach_client(base_session)
+
+    def detach_client(self, base_session: types.IAsyncBaseSession):
+        if base_session.realm not in self.realms:
+            raise ValueError(f"cannot detach client from non-existent realm {base_session.realm}")
+
+        self.realms[base_session.realm].detach_client(base_session)
+
+    async def receive_message(self, base_session: types.IAsyncBaseSession, msg: messages.Message):
+        if base_session.realm not in self.realms:
+            raise ValueError(f"cannot process message for non-existent realm {base_session.realm}")
+
+        await self.realms[base_session.realm].receive_message(base_session.id, msg)

xconn-0.1.0/xconn/server.py

@@ -0,0 +1,46 @@
+import aiohttp
+from aiohttp import web
+
+from xconn.router import Router
+from xconn.acceptor import AIOHttpAcceptor
+
+
+class Server:
+    def __init__(self, router: Router):
+        self.router = router
+
+    async def _websocket_handler(self, request):
+        ws = web.WebSocketResponse(protocols=["wamp.2.json", "wamp.2.cbor", "wamp.2.msgpack"])
+        # upgrade this connection to websocket.
+        await ws.prepare(request)
+
+        acceptor = AIOHttpAcceptor()
+        base_session = await acceptor.accept(ws)
+        self.router.attach_client(base_session)
+
+        while not ws.closed:
+            msg = await ws.receive()
+
+            if msg.type == aiohttp.WSMsgType.TEXT or msg.type == aiohttp.WSMsgType.BINARY:
+                msg = base_session.serializer.deserialize(msg.data)
+                await self.router.receive_message(base_session, msg)
+            elif msg.type == aiohttp.WSMsgType.ERROR:
+                print(f"Error: {msg.exception()}")
+            elif msg.type == aiohttp.WSMsgType.CLOSE:
+                print("Client disconnected")
+                break
+
+        return ws
+
+    async def start(self, host: str, port: int, start_loop: bool = False):
+        app = web.Application()
+        app.router.add_get("/ws", self._websocket_handler)
+
+        if start_loop:
+            web.run_app(app, host=host, port=port)
+        else:
+            runner = web.AppRunner(app)
+            await runner.setup()
+
+            site = aiohttp.web.TCPSite(runner, host=host, port=port)
+            await site.start()

xconn-0.1.0/xconn/session.py

@@ -0,0 +1,225 @@
+import asyncio
+from concurrent.futures import Future
+from threading import Thread
+from typing import Callable, Any
+
+from wampproto import messages, idgen, session
+
+from xconn import types
+
+
+class Session:
+    def __init__(self, base_session: types.BaseSession):
+        # RPC data structures
+        self.call_requests: dict[int, Future[types.Result]] = {}
+        self.register_requests: dict[int, types.RegisterRequest] = {}
+        self.registrations: dict[int, Callable[[types.Invocation], types.Result]] = {}
+        self.unregister_requests: dict[int, types.UnregisterRequest] = {}
+
+        # PubSub data structures
+        self.publish_requests: dict[int, Future[None]] = {}
+        self.subscribe_requests: dict[int, types.SubscribeRequest] = {}
+        self.subscriptions: dict[int, Callable[[types.Event], None]] = {}
+        self.unsubscribe_requests: dict[int, types.UnsubscribeRequest] = {}
+
+        # ID generator
+        self.idgen = idgen.SessionScopeIDGenerator()
+
+        self.base_session = base_session
+
+        # initialize the sans-io wamp session
+        self.session = session.WAMPSession(base_session.serializer)
+
+        thread = Thread(target=self.wait)
+        thread.start()
+
+    def wait(self):
+        while True:
+            try:
+                data = self.base_session.receive()
+            except Exception:
+                break
+
+            self.process_incoming_message(self.session.receive(data))
+
+    def process_incoming_message(self, msg: messages.Message):
+        if isinstance(msg, messages.Registered):
+            request = self.register_requests.pop(msg.request_id)
+            self.registrations[msg.registration_id] = request.endpoint
+            request.future.set_result(types.Registration(msg.registration_id))
+        elif isinstance(msg, messages.UnRegistered):
+            request = self.unregister_requests.pop(msg.request_id)
+            del self.registrations[request.registration_id]
+            request.future.set_result(None)
+        elif isinstance(msg, messages.Result):
+            request = self.call_requests.pop(msg.request_id)
+            request.set_result(types.Result(msg.args, msg.kwargs, msg.options))
+        elif isinstance(msg, messages.Invocation):
+            endpoint = self.registrations[msg.registration_id]
+            result = endpoint(msg)
+            data = self.session.send_message(messages.Yield(msg.request_id, result.args, result.kwargs, result.details))
+            self.base_session.send(data)
+        elif isinstance(msg, messages.Subscribed):
+            request = self.subscribe_requests.pop(msg.request_id)
+            self.subscriptions[msg.subscription_id] = request.endpoint
+            request.future.set_result(types.Subscription(msg.subscription_id))
+        elif isinstance(msg, messages.UnSubscribed):
+            request = self.unsubscribe_requests.pop(msg.request_id)
+            del self.subscriptions[request.subscription_id]
+            request.future.set_result(None)
+        elif isinstance(msg, messages.Published):
+            request = self.publish_requests.pop(msg.request_id)
+            request.set_result(None)
+        elif isinstance(msg, messages.Event):
+            endpoint = self.subscriptions[msg.subscription_id]
+            endpoint(types.Event(msg.args, msg.kwargs, msg.details))
+        elif isinstance(msg, messages.Error):
+            pass
+        else:
+            raise ValueError("received unknown message")
+
+    def call(self, procedure: str, args: list[Any] = None, kwargs: dict = None, options: dict = None) -> types.Result:
+        call = messages.Call(self.idgen.next(), procedure, args, kwargs, options)
+        data = self.session.send_message(call)
+
+        f = Future()
+        self.call_requests[call.request_id] = f
+        self.base_session.send(data)
+
+        return f.result()
+
+    def register(self, procedure: str, endpoint: Callable[[types.Invocation], types.Result]) -> types.Registration:
+        register = messages.Register(self.idgen.next(), procedure)
+        data = self.session.send_message(register)
+
+        f: Future[types.Registration] = Future()
+        self.register_requests[register.request_id] = types.RegisterRequest(f, endpoint)
+        self.base_session.send(data)
+
+        return f.result()
+
+    def unregister(self, reg: types.Registration):
+        unregister = messages.UnRegister(self.idgen.next(), reg.registration_id)
+        data = self.session.send_message(unregister)
+
+        f: Future = Future()
+        self.unregister_requests[unregister.request_id] = types.UnregisterRequest(f, reg.registration_id)
+        self.base_session.send(data)
+
+        f.result()
+
+    def subscribe(self, topic: str, endpoint: Callable[[types.Event], None]) -> types.Subscription:
+        subscribe = messages.Subscribe(self.idgen.next(), topic)
+        data = self.session.send_message(subscribe)
+
+        f: Future[types.Subscription] = Future()
+        self.subscribe_requests[subscribe.request_id] = types.SubscribeRequest(f, endpoint)
+        self.base_session.send(data)
+
+        return f.result()
+
+    def unsubscribe(self, sub: types.Subscription):
+        unsubscribe = messages.UnSubscribe(self.idgen.next(), sub.subscription_id)
+        data = self.session.send_message(unsubscribe)
+
+        f: Future = Future()
+        self.unsubscribe_requests[unsubscribe.request_id] = types.UnsubscribeRequest(f, sub.subscription_id)
+        self.base_session.send(data)
+
+        f.result()
+
+    def publish(self, topic: str, args: list[Any] = None, kwargs: dict = None, options: dict = None):
+        publish = messages.Publish(self.idgen.next(), topic, args, kwargs, options)
+        data = self.session.send_message(publish)
+
+        if options is not None and options.get("acknowledge", True):
+            f: Future = Future()
+            self.publish_requests[publish.request_id] = f
+            self.base_session.send(data)
+            return f.result()
+
+        self.base_session.send(data)
+
+
+class AsyncSession:
+    def __init__(self, base_session: types.IAsyncBaseSession):
+        # RPC data structures
+        self.call_requests: dict[int, Future[types.Result]] = {}
+        self.register_requests: dict[int, types.RegisterRequest] = {}
+        self.registrations: dict[int, Callable[[types.Invocation], types.Result]] = {}
+        self.unregister_requests: dict[int, types.UnregisterRequest] = {}
+
+        # PubSub data structures
+        self.publish_requests: dict[int, Future[None]] = {}
+        self.subscribe_requests: dict[int, types.SubscribeRequest] = {}
+        self.subscriptions: dict[int, Callable[[types.Event], None]] = {}
+        self.unsubscribe_requests: dict[int, types.UnsubscribeRequest] = {}
+
+        # ID generator
+        self.idgen = idgen.SessionScopeIDGenerator()
+
+        self.base_session = base_session
+
+        # initialize the sans-io wamp session
+        self.session = session.WAMPSession(base_session.serializer)
+
+        loop = asyncio.get_event_loop()
+        loop.create_task(self.wait())
+
+    async def wait(self):
+        while True:
+            try:
+                data = await self.base_session.receive()
+            except Exception as e:
+                print(e)
+                break
+
+            await self.process_incoming_message(self.session.receive(data))
+
+    async def process_incoming_message(self, msg: messages.Message):
+        if isinstance(msg, messages.Registered):
+            request = self.register_requests.pop(msg.request_id)
+            self.registrations[msg.registration_id] = request.endpoint
+            request.future.set_result(types.Registration(msg.registration_id))
+        elif isinstance(msg, messages.UnRegistered):
+            request = self.unregister_requests.pop(msg.request_id)
+            del self.registrations[request.registration_id]
+            request.future.set_result(None)
+        elif isinstance(msg, messages.Result):
+            request = self.call_requests.pop(msg.request_id)
+            request.set_result(types.Result(msg.args, msg.kwargs, msg.options))
+        elif isinstance(msg, messages.Invocation):
+            endpoint = self.registrations[msg.registration_id]
+            result = endpoint(msg)
+            data = self.session.send_message(messages.Yield(msg.request_id, result.args, result.kwargs, result.details))
+            await self.base_session.send(data)
+        elif isinstance(msg, messages.Subscribed):
+            request = self.subscribe_requests.pop(msg.request_id)
+            self.subscriptions[msg.subscription_id] = request.endpoint
+            request.future.set_result(types.Subscription(msg.subscription_id))
+        elif isinstance(msg, messages.UnSubscribed):
+            request = self.unsubscribe_requests.pop(msg.request_id)
+            del self.subscriptions[request.subscription_id]
+            request.future.set_result(None)
+        elif isinstance(msg, messages.Published):
+            request = self.publish_requests.pop(msg.request_id)
+            request.set_result(None)
+        elif isinstance(msg, messages.Event):
+            endpoint = self.subscriptions[msg.subscription_id]
+            endpoint(types.Event(msg.args, msg.kwargs, msg.details))
+        elif isinstance(msg, messages.Error):
+            pass
+        else:
+            raise ValueError("received unknown message")
+
+    async def register(
+        self, procedure: str, endpoint: Callable[[types.Invocation], types.Result]
+    ) -> Future[types.Registration]:
+        register = messages.Register(self.idgen.next(), procedure, options={})
+        data = self.session.send_message(register)
+
+        f: Future[types.Registration] = Future()
+        self.register_requests[register.request_id] = types.RegisterRequest(f, endpoint)
+        await self.base_session.send(data)
+
+        return f

xconn-0.1.0/xconn/types.py

@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import asyncio
+from asyncio import Future
+from collections import deque
+from dataclasses import dataclass
+from typing import Callable
+
+from aiohttp import web
+from websockets.sync.connection import Connection
+from wampproto import messages, joiner, serializers
+
+
+@dataclass
+class Registration:
+    registration_id: int
+
+
+@dataclass
+class RegisterRequest:
+    future: Future[Registration]
+    endpoint: Callable[[Invocation], Result]
+
+
+@dataclass
+class UnregisterRequest:
+    future: Future
+    registration_id: int
+
+
+@dataclass
+class Subscription:
+    subscription_id: int
+
+
+@dataclass
+class SubscribeRequest:
+    future: Future[Subscription]
+    endpoint: Callable[[Event], None]
+
+
+@dataclass
+class UnsubscribeRequest:
+    future: Future
+    subscription_id: int
+
+
+@dataclass
+class Result:
+    args: list | None = None
+    kwargs: dict | None = None
+    details: dict | None = None
+
+
+@dataclass
+class Invocation:
+    args: list | None
+    kwargs: dict | None
+    details: dict | None
+
+
+@dataclass
+class Event:
+    args: list | None
+    kwargs: dict | None
+    details: dict | None
+
+
+class IBasePeer:
+    def read(self) -> str | bytes:
+        raise NotImplementedError()
+
+    def write(self, data: str | bytes):
+        raise NotImplementedError()
+
+
+class BasePeer(IBasePeer):
+    def read(self) -> str | bytes:
+        return super().read()
+
+    def write(self, data: str | bytes):
+        super().write(data)
+
+
+class IPeer:
+    def read(self) -> str | bytes:
+        raise NotImplementedError()
+
+    def write(self, data: str | bytes):
+        raise NotImplementedError()
+
+    def read_message(self) -> messages.Message:
+        raise NotImplementedError()
+
+    def write_message(self, msg: messages.Message):
+        raise NotImplementedError()
+
+
+class Peer(IPeer):
+    def __init__(self, base_peer: BasePeer):
+        super().__init__()
+        self._base_peer = base_peer
+
+
+class IBaseSession:
+    @property
+    def id(self) -> int:
+        raise NotImplementedError()
+
+    @property
+    def realm(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def authid(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def authrole(self) -> str:
+        raise NotImplementedError()
+
+    def send(self, data: bytes):
+        raise NotImplementedError()
+
+    def receive(self) -> bytes:
+        raise NotImplementedError()
+
+    def send_message(self, msg: messages.Message):
+        raise NotImplementedError()
+
+    def receive_message(self) -> messages.Message:
+        raise NotImplementedError()
+
+    def close(self):
+        raise NotImplementedError()
+
+
+class BaseSession(IBaseSession):
+    def __init__(self, ws: Connection, session_details: joiner.SessionDetails, serializer: serializers.Serializer):
+        super().__init__()
+        self.ws = ws
+        self.session_details = session_details
+        self.serializer = serializer
+
+    @property
+    def id(self) -> int:
+        return self.session_details.session_id
+
+    @property
+    def realm(self) -> str:
+        return self.session_details.realm
+
+    @property
+    def authid(self) -> str:
+        return self.session_details.authid
+
+    @property
+    def authrole(self) -> str:
+        return self.session_details.authrole
+
+    def send(self, data: bytes):
+        self.ws.send(data)
+
+    def receive(self) -> bytes:
+        return self.ws.recv()
+
+    def send_message(self, msg: messages.Message):
+        self.ws.send(self.serializer.serialize(msg))
+
+    def receive_message(self) -> messages.Message:
+        return self.serializer.deserialize(self.receive())
+
+    def close(self):
+        self.ws.close()
+
+
+class IAsyncBaseSession:
+    @property
+    def id(self) -> int:
+        raise NotImplementedError()
+
+    @property
+    def realm(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def authid(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def authrole(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def serializer(self) -> serializers.Serializer:
+        raise NotImplementedError()
+
+    async def send(self, data: bytes | str):
+        raise NotImplementedError()
+
+    async def receive(self) -> bytes | str:
+        raise NotImplementedError()
+
+    async def send_message(self, msg: messages.Message):
+        raise NotImplementedError()
+
+    async def receive_message(self) -> messages.Message:
+        raise NotImplementedError()
+
+    async def close(self):
+        raise NotImplementedError()
+
+
+class AIOHttpBaseSession(IAsyncBaseSession):
+    def __init__(
+        self, ws: web.WebSocketResponse, session_details: joiner.SessionDetails, serializer: serializers.Serializer
+    ):
+        super().__init__()
+        self.ws = ws
+        self.session_details = session_details
+        self._serializer = serializer
+
+    @property
+    def id(self) -> int:
+        return self.session_details.session_id
+
+    @property
+    def realm(self) -> str:
+        return self.session_details.realm
+
+    @property
+    def authid(self) -> str:
+        return self.session_details.authid
+
+    @property
+    def authrole(self) -> str:
+        return self.session_details.authrole
+
+    @property
+    def serializer(self) -> serializers.Serializer:
+        return self._serializer
+
+    async def send(self, data: bytes):
+        await self.ws.send_bytes(data)
+
+    async def receive(self) -> bytes:
+        return await self.ws.receive_bytes()
+
+    async def send_message(self, msg: messages.Message):
+        await self.send(self.serializer.serialize(msg))
+
+    async def receive_message(self) -> messages.Message:
+        return self.serializer.deserialize(await self.receive())
+
+    async def close(self):
+        await self.ws.close()
+
+
+class ClientSideLocalBaseSession(IAsyncBaseSession):
+    def __init__(self, sid: int, realm: str, authid: str, authrole: str, serializer: serializers.Serializer, router):
+        super().__init__()
+        self._sid: int = sid
+        self._realm: str = realm
+        self._authid: str = authid
+        self._authrole: str = authrole
+        self._serializer: serializers.Serializer = serializer
+        self._router = router
+
+        self._incoming_messages = deque()
+        self._cond = asyncio.Condition()
+
+    @property
+    def id(self) -> int:
+        return self._sid
+
+    @property
+    def realm(self) -> str:
+        return self._realm
+
+    @property
+    def authid(self) -> str:
+        return self._authid
+
+    @property
+    def authrole(self) -> str:
+        return self._authrole
+
+    @property
+    def serializer(self) -> serializers.Serializer:
+        return self._serializer
+
+    async def send(self, data: bytes | str):
+        await self.send_message(self.serializer.deserialize(data))
+
+    async def receive(self) -> bytes | str:
+        async with self._cond:
+            while not self._incoming_messages:
+                await self._cond.wait()
+
+            return self._incoming_messages.popleft()
+
+    async def send_message(self, msg: messages.Message):
+        await self._router.receive_message(self, msg)
+
+    async def receive_message(self) -> messages.Message:
+        return self.serializer.deserialize(await self.receive())
+
+    async def close(self):
+        pass
+
+    async def feed(self, data: bytes | str):
+        async with self._cond:
+            self._incoming_messages.append(data)
+            self._cond.notify()
+
+
+class ServerSideLocalBaseSession(IAsyncBaseSession):
+    def __init__(self, sid: int, realm: str, authid: str, authrole: str, serializer: serializers.Serializer):
+        super().__init__()
+        self._sid: int = sid
+        self._realm: str = realm
+        self._authid: str = authid
+        self._authrole: str = authrole
+        self._serializer: serializers.Serializer = serializer
+        self._other: ClientSideLocalBaseSession = None
+
+    def set_other(self, other: ClientSideLocalBaseSession):
+        self._other = other
+
+    @property
+    def id(self) -> int:
+        return self._sid
+
+    @property
+    def realm(self) -> str:
+        return self._realm
+
+    @property
+    def authid(self) -> str:
+        return self._authid
+
+    @property
+    def authrole(self) -> str:
+        return self._authrole
+
+    @property
+    def serializer(self) -> serializers.Serializer:
+        return self._serializer
+
+    async def send(self, data: bytes | str):
+        await self._other.feed(data)
+
+    async def send_message(self, msg: messages.Message):
+        await self.send(self.serializer.serialize(msg))
+
+    async def close(self):
+        pass

xconn-0.1.0/xconn.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.1
+Name: xconn
+Version: 0.1.0
+Summary: https://github.com/xconnio/xconn-python
+Author-email: Omer Akram <omer@thing.com>, Mahad Munir <mahad@xconn.io>
+License: MIT License
+        
+        Copyright (c) 2024 XConnIO
+        Copyright (c) 2024 Simple Things Inc.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/xconnio/xconn-python
+Project-URL: Bug Tracker, https://github.com/xconnio/xconn-python/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websockets
+Requires-Dist: wampproto
+Requires-Dist: aiohttp
+Requires-Dist: uvloop
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: ruff; extra == "test"
+
+# XConn Python

xconn-0.1.0/xconn.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+xconn/__init__.py
+xconn/__main__.py
+xconn/acceptor.py
+xconn/app.py
+xconn/client.py
+xconn/helpers.py
+xconn/joiner.py
+xconn/realm.py
+xconn/router.py
+xconn/server.py
+xconn/session.py
+xconn/types.py
+xconn.egg-info/PKG-INFO
+xconn.egg-info/SOURCES.txt
+xconn.egg-info/dependency_links.txt
+xconn.egg-info/entry_points.txt
+xconn.egg-info/requires.txt
+xconn.egg-info/top_level.txt

xconn-0.1.0/xconn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xconn-0.1.0/xconn.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xconn = xconn.__main__:main

xconn-0.1.0/xconn.egg-info/requires.txt

@@ -0,0 +1,10 @@
+websockets
+wampproto
+aiohttp
+uvloop
+
+[test]
+coverage
+pytest
+pytest-asyncio
+ruff

xconn-0.1.0/xconn.egg-info/top_level.txt

@@ -0,0 +1 @@
+xconn