feat: initial setup for python SDK

Author: Parizval

sdk/python/.gitignore

@@ -0,0 +1 @@
+src/rrelayer/__pycache__/

sdk/python/.python-version

@@ -0,0 +1 @@
+3.13

sdk/python/README.md

@@ -0,0 +1,17 @@
+[project]
+name = "rrelayer"
+version = "0.1.0"
+description = "The rrelayer sdk"
+readme = "README.md"
+authors = [
+    { name = "parizval", email = "[email protected]" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "pydantic>=2.12.3",
+    "web3>=7.14.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.2,<0.10.0"]
+build-backend = "uv_build"

sdk/python/pyproject.toml

@@ -0,0 +1,52 @@
+import aiohttp
+import asyncio
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+
+
+class API(BaseModel):
+    _session: aiohttp.ClientSession | None = PrivateAttr(default=None)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __del__(self):
+        if self._session and not self._session.closed:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._session.close())
+            except RuntimeError:
+                # No running event loop (e.g., program exit) — close synchronously
+                asyncio.run(self._session.close())
+        print("Destroyed API Session")
+
+    async def _get_session(self):
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def getApi(self, url: str) -> dict:
+        session = await self._get_session()
+        async with session.get(url) as response:
+            print(response.content_type)
+            return await response.json()
+
+    async def postApi(self, url: str, headers, body) -> dict:
+        session = await self._get_session()
+
+        async with session.post(url) as response:
+            return await response.json()
+
+    async def putApi(self, url: str, headers, body) -> dict:
+        session = await self._get_session()
+
+        async with session.put(url) as response:
+            return await response.json()
+
+    async def deleteApi(self, url: str, headers, body) -> dict:
+        session = await self._get_session()
+
+        async with session.delete(url) as response:
+            return await response.json()
+
+    async def close(self):
+        if self._session and not self._session.closed:
+            await self._session.close()

sdk/python/src/rrelayer/__init__.py

@@ -0,0 +1,79 @@
+from pydantic import BaseModel, validate_call, ConfigDict, PrivateAttr
+from rrelayer.api import API
+
+
+class Client(BaseModel):
+    _serverURL: str = PrivateAttr()
+    _auth_username: str = PrivateAttr()
+    _auth_password: str = PrivateAttr()
+    _api: API = PrivateAttr()
+
+    relayer: "Client.Relayer" = None
+    network: "Client.Network | None" = None
+    transaction: "Client.Transaction | None" = None
+    allowlist: "Client.AllowList | None" = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __init__(self, serverURL: str, auth_username: str, auth_password: str, **data):
+        super().__init__(**data)
+
+        self._serverURL = serverURL
+        self._auth_username = auth_username
+        self._auth_password = auth_password
+
+        self._api = API()
+
+        self.relayer = self.Relayer(self)
+        self.network = self.Network(self)
+        self.transaction = self.Transaction(self)
+        self.allowlist = self.AllowList(self)
+
+    class Relayer:
+        def __init__(self, client: "Client"):
+            self._client: "Client" = client
+
+        @validate_call
+        async def create(self, chainId: int, name: str):
+            pass
+
+        @validate_call
+        async def clone(self, relayerId: str, chainId: int, name: str):
+            pass
+
+        @validate_call
+        async def delete(self, id: str):
+            pass
+
+        @validate_call
+        async def get(self, id: str):
+            pass
+
+        @validate_call
+        async def getAll(self):
+            pass
+
+        def printValues(self):
+            print("Print Values")
+            print(self._client._auth_username)
+
+    class Network:
+        def __init__(self, client: "Client"):
+            self._client: "Client" = client
+
+    class Transaction:
+        def __init__(self, client: "Client"):
+            self._client: "Client" = client
+
+    class AllowList:
+        def __init__(self, client: "Client"):
+            self._client: "Client" = client
+
+
+@validate_call
+def createClient(serverURL: str, auth_username: str, auth_password: str) -> Client:
+    return Client(
+        serverURL=serverURL,
+        auth_username=auth_username,
+        auth_password=auth_password,
+    )

sdk/python/src/rrelayer/api.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+from asyncinit import asyncinit
+from web3 import AsyncWeb3
+
+
+@asyncinit
+class Relayer(BaseModel):
+    _id: str = PrivateAttr()
+
+    _apiBaseConfig: dict = PrivateAttr()
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    _ethereumProvider: AsyncWeb3 | None = None
+
+    def __init__(
+        self,
+        serverURL: str,
+        providerUrl: str,
+        relayerId: str,
+        auth: dict[str, str],
+        **data,
+    ):
+        super().__init__(**data)
+
+        self._id = relayerId
+
+        self._ethereumProvider = await AsyncWeb3(
+            AsyncWeb3.AsyncHTTPProvider(providerUrl)
+        )
+
+        if "apiKey" in auth:
+            self._apiBaseConfig = {"apiKey": auth["apiKey"], "serverURL": serverURL}
+        elif "username" in auth and "password" in auth:
+            self._apiBaseConfig = {
+                "username": auth["username"],
+                "password": auth["password"],
+                "serverURL": serverURL,
+            }
+        else:
+            raise ValueError("Invalid authentication credentials")
+
+    @property
+    def name(self):
+        return self._id