relst 1.1.0__tar.gz

relst-1.1.0/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: relst
+Version: 1.1.0
+Summary: Expose any python object as an API: relst server and client over json, xml and a compact binary protocol
+Home-page: https://pypi.org/project/relst/
+Author: Ariel Tubul
+Author-email: avarti765@gmail.com
+Project-URL: Source, https://github.com/mon231/relst
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: flask
+Requires-Dist: waitress
+Requires-Dist: requests
+Requires-Dist: firstclass
+Provides-Extra: gui
+Requires-Dist: eel; extra == "gui"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# relst
+
+Expose any python object as an API, and call it from python as if it were local.
+One server, three wire formats: **json**, **xml** and a very small **binary** protocol,
+plus a swagger-like console to trace and hand-craft requests.
+
+[![PyPI](https://img.shields.io/pypi/v/relst)](https://pypi.org/project/relst/)
+
+## Installation
+
+```bash
+pip install relst
+```
+
+Python 3.10+. Optional desktop client extras: `pip install "relst[gui]"`.
+Source code: <https://github.com/mon231/relst>
+
+## Quick start
+
+Server:
+
+```py
+from relst.server import RelstTextualServer
+
+
+class Calculator:
+    """Server's help string"""
+
+    def add(self, a: int, b: int = 10) -> int:
+        "Help string of this method"
+        return a + b
+
+    async def shout(self, text: str) -> str:
+        return text.upper()
+
+    def _not_exposed(self):
+        return 'MySecretCode'
+
+
+RelstTextualServer(1736, Calculator()).serve()
+```
+
+Client:
+
+```py
+from relst.client import RelstFlaskClient
+
+with RelstFlaskClient('127.0.0.1', 1736, protocol='binary') as client:   # json | xml | binary
+    print(client.add(1, b=2))      # 3, server methods became python methods
+    print(client.shout('hi'))      # 'HI'
+    print(client.METHOD_HELP('add'))
+```
+
+Open <http://127.0.0.1:1736/_relst/ui> for the console. More in [`examples/`](examples/README.md).
+
+## What gets exposed
+
+Every public (not starting with `_`) method of the handler object: instance methods, `staticmethod`,
+`classmethod`, and `async def` coroutines. Arguments are keyword arguments, validated against the
+method signature before the call (`400` on mismatch). Type hints are used to rebuild values:
+`float` accepts ints, `bytes` accepts hex strings, and `firstclass` / dataclass hints accept dicts.
+
+Return values may be `None`, `bool`, `int`, `float`, `str`, `bytes`, lists/tuples/sets, dicts,
+enums, dataclasses and [`firstclass`](https://pypi.org/project/firstclass/) objects.
+
+Failures reach the client as `RelstRemoteError(code, message)`:
+
+| code | meaning |
+|---|---|
+| 400 | malformed payload, bad / missing arguments, bad value for a `firstclass` argument |
+| 404 | unknown (or private) method |
+| 413 | request bigger than 1 MiB (http) |
+| 415 | unsupported `Content-Type` |
+| 500 | the method raised, the message is generic, details stay in the server log |
+
+Built-in methods (`__get_class_name`, `__get_class_help`, `__get_methods_list`, `__get_method_help`,
+`__update_server`) power the client's `CLASS_NAME()`, `CLASS_HELP()`, `METHOD_HELP(name)`,
+`UPDATE_SERVER()` and `UPDATE_METHODS()`. Uppercase client names are reserved, a server method can
+never shadow them.
+
+## Servers and clients
+
+| class | transport | protocols |
+|---|---|---|
+| `RelstTextualServer(port, handler, host='127.0.0.1', enable_ui=True, trace_limit=500)` | http (waitress + flask) | json, xml, binary by `Content-Type` |
+| `RelstBinaryServer(port, handler, host='127.0.0.1')` | raw tcp, connections are reused | binary |
+| `RelstFlaskClient(address, port, is_https=False, protocol='json')` | http | json, xml, binary |
+| `RelstSocketClient(address, port)` | tcp (thread-safe, auto-reconnect) | binary |
+
+Servers bind to `127.0.0.1` by default; pass `host='0.0.0.0'` to expose them. `serve()` blocks,
+`start()` / `stop()` / `with server:` run in the background (`port=0` picks a free port, read it
+from `server.port`).
+
+## Protocols
+
+The protocol of an http request is picked by `Content-Type` (default json), the response uses the
+same protocol unless `Accept` names another one. The method name is the url path: `POST /add`.
+
+### json (`application/json`)
+
+Body is an object of keyword arguments, the response body is the returned value.
+Things json can't carry are wrapped: bytes as `{"$bytes": "00ff"}`, nan/inf as `{"$float": "nan"}`
+(a dict that itself has `$`-keys is wrapped in `{"$dict": ...}`).
+Errors: `{"error": {"code": 404, "message": "..."}}` with the matching http status.
+
+### xml (`application/xml`)
+
+```xml
+<request method="add">
+  <arg name="a"><value type="int">1</value></arg>
+</request>
+<!-- response -->  <response><value type="int">11</value></response>
+<!-- error -->     <error code="404">Method x does not exist</error>
+```
+
+Value types: `none bool int float str bytes list dict`; `<value>` without a type is a string,
+strings that xml can't carry (control characters, `\r`) travel as `encoding="base64"`.
+DTDs / entities are rejected.
+
+### binary (`application/octet-stream`, also raw tcp)
+
+Built for minimal traffic: a 1-byte header, varint sizes (unsigned LEB128, uint32 range), no magic,
+no padding.
+
+```
+frame    = header:1  [name_size:varint name:utf8]  payload_size:varint  payload
+header   = FrameKind:2 bits | version:2 bits | reserved:4 bits       (a firstclass bitfield struct)
+FrameKind: REQUEST=0  RESPONSE=1  ERROR=2
+```
+
+- The `name` part exists only in requests, and is empty (1 byte) over http where the url has the method.
+- An empty payload is `{}` in a request and `None` in a response.
+- An error payload is the value `[code, message]`.
+
+```
+value (first byte)
+  1xxxxxxx   small uint 0..127                  (1 byte total)
+  01xxxxxx   str, 0..63 utf8 bytes follow
+  001xxxxx   list, 0..31 elements follow
+  0001xxxx   dict, 0..15 key/value pairs follow
+  0000xxxx   ValueTag: NONE=0 FALSE=1 TRUE=2 INT=3 FLOAT32=4 FLOAT64=5 STR=6 BYTES=7 LIST=8 DICT=9
+             INT is a zigzag varint (any size), STR/BYTES/LIST/DICT carry a varint size or count,
+             floats are 4 bytes when that is lossless, else 8 (big-endian)
+```
+
+The same call `{"prefix": "pre", "text": "txt", "count": 3, "flag": true, "blob": b"\x00\x01"}`:
+json 86 bytes, xml 324 bytes, binary 46 bytes (`python examples/wire_formats.py`).
+
+Safety limits (all protocols): nesting depth 64, 1 MiB per http body / tcp frame, forged lengths
+and counts are rejected before allocating, bad input is always a `400` / `RelstProtocolError`,
+never a crash.
+
+## Console (swagger-like UI)
+
+`http://<host>:<port>/_relst/ui` on every `RelstTextualServer`:
+
+- **Methods**: signatures, docstrings, a generated form per method; run it in json, xml or binary.
+- **Generate request**: shows the raw request (text, or hex for binary) without sending it.
+  Edit the bytes freely and **Send raw** to test malformed or hand-written payloads.
+- **Traces**: live table of everything the server handled (http, tcp and console calls) with raw
+  request/response, status and duration. `GET /_relst/traces?after=<id>` returns the same as json,
+  `DELETE /_relst/traces` clears it. `RelstBinaryServer.traces` is available in code for tcp.
+
+Disable with `enable_ui=False`. Executing methods from the console needs a json POST (so
+other websites can't trigger calls through your browser), keep the default `127.0.0.1` bind
+unless you trust the network.
+
+## Development
+
+```bash
+git clone https://github.com/mon231/relst
+cd relst
+pip install -e ".[dev]"
+python -m pytest tests
+```
+
+The suite (250+ tests) covers property-based round trips of every protocol, fuzzed / mutated /
+hostile payloads (XML entity bombs, deep nesting, huge ints, forged binary lengths), http and tcp
+end-to-end behavior, concurrency, server restarts and the console endpoints.
+
+Publishing:
+
+```bash
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```

relst-1.1.0/README.md

@@ -0,0 +1,187 @@
+# relst
+
+Expose any python object as an API, and call it from python as if it were local.
+One server, three wire formats: **json**, **xml** and a very small **binary** protocol,
+plus a swagger-like console to trace and hand-craft requests.
+
+[![PyPI](https://img.shields.io/pypi/v/relst)](https://pypi.org/project/relst/)
+
+## Installation
+
+```bash
+pip install relst
+```
+
+Python 3.10+. Optional desktop client extras: `pip install "relst[gui]"`.
+Source code: <https://github.com/mon231/relst>
+
+## Quick start
+
+Server:
+
+```py
+from relst.server import RelstTextualServer
+
+
+class Calculator:
+    """Server's help string"""
+
+    def add(self, a: int, b: int = 10) -> int:
+        "Help string of this method"
+        return a + b
+
+    async def shout(self, text: str) -> str:
+        return text.upper()
+
+    def _not_exposed(self):
+        return 'MySecretCode'
+
+
+RelstTextualServer(1736, Calculator()).serve()
+```
+
+Client:
+
+```py
+from relst.client import RelstFlaskClient
+
+with RelstFlaskClient('127.0.0.1', 1736, protocol='binary') as client:   # json | xml | binary
+    print(client.add(1, b=2))      # 3, server methods became python methods
+    print(client.shout('hi'))      # 'HI'
+    print(client.METHOD_HELP('add'))
+```
+
+Open <http://127.0.0.1:1736/_relst/ui> for the console. More in [`examples/`](examples/README.md).
+
+## What gets exposed
+
+Every public (not starting with `_`) method of the handler object: instance methods, `staticmethod`,
+`classmethod`, and `async def` coroutines. Arguments are keyword arguments, validated against the
+method signature before the call (`400` on mismatch). Type hints are used to rebuild values:
+`float` accepts ints, `bytes` accepts hex strings, and `firstclass` / dataclass hints accept dicts.
+
+Return values may be `None`, `bool`, `int`, `float`, `str`, `bytes`, lists/tuples/sets, dicts,
+enums, dataclasses and [`firstclass`](https://pypi.org/project/firstclass/) objects.
+
+Failures reach the client as `RelstRemoteError(code, message)`:
+
+| code | meaning |
+|---|---|
+| 400 | malformed payload, bad / missing arguments, bad value for a `firstclass` argument |
+| 404 | unknown (or private) method |
+| 413 | request bigger than 1 MiB (http) |
+| 415 | unsupported `Content-Type` |
+| 500 | the method raised, the message is generic, details stay in the server log |
+
+Built-in methods (`__get_class_name`, `__get_class_help`, `__get_methods_list`, `__get_method_help`,
+`__update_server`) power the client's `CLASS_NAME()`, `CLASS_HELP()`, `METHOD_HELP(name)`,
+`UPDATE_SERVER()` and `UPDATE_METHODS()`. Uppercase client names are reserved, a server method can
+never shadow them.
+
+## Servers and clients
+
+| class | transport | protocols |
+|---|---|---|
+| `RelstTextualServer(port, handler, host='127.0.0.1', enable_ui=True, trace_limit=500)` | http (waitress + flask) | json, xml, binary by `Content-Type` |
+| `RelstBinaryServer(port, handler, host='127.0.0.1')` | raw tcp, connections are reused | binary |
+| `RelstFlaskClient(address, port, is_https=False, protocol='json')` | http | json, xml, binary |
+| `RelstSocketClient(address, port)` | tcp (thread-safe, auto-reconnect) | binary |
+
+Servers bind to `127.0.0.1` by default; pass `host='0.0.0.0'` to expose them. `serve()` blocks,
+`start()` / `stop()` / `with server:` run in the background (`port=0` picks a free port, read it
+from `server.port`).
+
+## Protocols
+
+The protocol of an http request is picked by `Content-Type` (default json), the response uses the
+same protocol unless `Accept` names another one. The method name is the url path: `POST /add`.
+
+### json (`application/json`)
+
+Body is an object of keyword arguments, the response body is the returned value.
+Things json can't carry are wrapped: bytes as `{"$bytes": "00ff"}`, nan/inf as `{"$float": "nan"}`
+(a dict that itself has `$`-keys is wrapped in `{"$dict": ...}`).
+Errors: `{"error": {"code": 404, "message": "..."}}` with the matching http status.
+
+### xml (`application/xml`)
+
+```xml
+<request method="add">
+  <arg name="a"><value type="int">1</value></arg>
+</request>
+<!-- response -->  <response><value type="int">11</value></response>
+<!-- error -->     <error code="404">Method x does not exist</error>
+```
+
+Value types: `none bool int float str bytes list dict`; `<value>` without a type is a string,
+strings that xml can't carry (control characters, `\r`) travel as `encoding="base64"`.
+DTDs / entities are rejected.
+
+### binary (`application/octet-stream`, also raw tcp)
+
+Built for minimal traffic: a 1-byte header, varint sizes (unsigned LEB128, uint32 range), no magic,
+no padding.
+
+```
+frame    = header:1  [name_size:varint name:utf8]  payload_size:varint  payload
+header   = FrameKind:2 bits | version:2 bits | reserved:4 bits       (a firstclass bitfield struct)
+FrameKind: REQUEST=0  RESPONSE=1  ERROR=2
+```
+
+- The `name` part exists only in requests, and is empty (1 byte) over http where the url has the method.
+- An empty payload is `{}` in a request and `None` in a response.
+- An error payload is the value `[code, message]`.
+
+```
+value (first byte)
+  1xxxxxxx   small uint 0..127                  (1 byte total)
+  01xxxxxx   str, 0..63 utf8 bytes follow
+  001xxxxx   list, 0..31 elements follow
+  0001xxxx   dict, 0..15 key/value pairs follow
+  0000xxxx   ValueTag: NONE=0 FALSE=1 TRUE=2 INT=3 FLOAT32=4 FLOAT64=5 STR=6 BYTES=7 LIST=8 DICT=9
+             INT is a zigzag varint (any size), STR/BYTES/LIST/DICT carry a varint size or count,
+             floats are 4 bytes when that is lossless, else 8 (big-endian)
+```
+
+The same call `{"prefix": "pre", "text": "txt", "count": 3, "flag": true, "blob": b"\x00\x01"}`:
+json 86 bytes, xml 324 bytes, binary 46 bytes (`python examples/wire_formats.py`).
+
+Safety limits (all protocols): nesting depth 64, 1 MiB per http body / tcp frame, forged lengths
+and counts are rejected before allocating, bad input is always a `400` / `RelstProtocolError`,
+never a crash.
+
+## Console (swagger-like UI)
+
+`http://<host>:<port>/_relst/ui` on every `RelstTextualServer`:
+
+- **Methods**: signatures, docstrings, a generated form per method; run it in json, xml or binary.
+- **Generate request**: shows the raw request (text, or hex for binary) without sending it.
+  Edit the bytes freely and **Send raw** to test malformed or hand-written payloads.
+- **Traces**: live table of everything the server handled (http, tcp and console calls) with raw
+  request/response, status and duration. `GET /_relst/traces?after=<id>` returns the same as json,
+  `DELETE /_relst/traces` clears it. `RelstBinaryServer.traces` is available in code for tcp.
+
+Disable with `enable_ui=False`. Executing methods from the console needs a json POST (so
+other websites can't trigger calls through your browser), keep the default `127.0.0.1` bind
+unless you trust the network.
+
+## Development
+
+```bash
+git clone https://github.com/mon231/relst
+cd relst
+pip install -e ".[dev]"
+python -m pytest tests
+```
+
+The suite (250+ tests) covers property-based round trips of every protocol, fuzzed / mutated /
+hostile payloads (XML entity bombs, deep nesting, huge ints, forged binary lengths), http and tcp
+end-to-end behavior, concurrency, server restarts and the console endpoints.
+
+Publishing:
+
+```bash
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```

relst-1.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

relst-1.1.0/relst/__init__.py

@@ -0,0 +1,3 @@
+from . import protocol
+from . import server
+from . import client

relst-1.1.0/relst/client/__init__.py

@@ -0,0 +1,3 @@
+from .relst_client import RelstClient
+from .relst_flask_client import RelstFlaskClient
+from .relst_socket_client import RelstSocketClient

relst-1.1.0/relst/client/relst_client.py

@@ -0,0 +1,100 @@
+from typing import Dict, Set, Tuple
+from abc import ABC, abstractmethod
+from ..protocol import Codec, get_codec, DEFAULT_PROTOCOL
+
+
+GET_CLASS_NAME_REQUEST = '__get_class_name'
+GET_CLASS_HELP_REQUEST = '__get_class_help'
+GET_METHODS_LIST_REQUEST = '__get_methods_list'
+GET_METHOD_HELP_REQUEST = '__get_method_help'
+UPDATE_SERVER_REQUEST = '__update_server'
+
+PRIVATE_OR_PROTECTED_PREFIX = '_'
+
+
+class RelstClient(ABC):
+    """
+    Client of a relst server. After UPDATE_METHODS (or entering a `with` block)
+    every public server-method is available as a python method of the client.
+    NOTE: Uppercase names are reserved for the client, server methods can't override them
+    """
+
+    def __init__(self, protocol: str = DEFAULT_PROTOCOL):
+        self._codec: Codec = get_codec(protocol)
+        self._dynamic_methods: Set[str] = set()
+
+    # NOTE: transports that carry the method-name themselves (http url) set this to False
+    _embed_method = True
+
+    def UPDATE_METHODS(self):
+        self._remove_methods()
+        methods_list = self._handle_request(GET_METHODS_LIST_REQUEST)
+
+        for method_name, method_description in methods_list.items():
+            self._add_method(method_name, method_description)
+
+    def CLASS_NAME(self) -> str:
+        return self._handle_request(GET_CLASS_NAME_REQUEST)
+
+    def CLASS_HELP(self) -> str:
+        return self._handle_request(GET_CLASS_HELP_REQUEST)
+
+    def METHOD_HELP(self, method_name: str) -> str:
+        return self._handle_request(GET_METHOD_HELP_REQUEST, method_name=method_name)
+
+    def UPDATE_SERVER(self):
+        self._handle_request(UPDATE_SERVER_REQUEST)
+
+    def _handle_request(self, method_name: str, /, **method_args):
+        """
+        :except: RelstRemoteError when the server reports an error, RelstProtocolError for bad payloads
+        """
+
+        request = self._codec.encode_request(method_name, method_args, embed_method=self._embed_method)
+        status, response = self._send(method_name, request)
+        return self._codec.decode_response(response, status)
+
+    @abstractmethod
+    def _send(self, method_name: str, request: bytes) -> Tuple[int, bytes]:
+        """transport-level exchange, returns (http-like status, response bytes)"""
+
+    def _remove_methods(self):
+        for method_name in self._dynamic_methods:
+            self.__dict__.pop(method_name, None)
+
+        self._dynamic_methods.clear()
+
+    def _add_method(self, method_name: str, description: Dict):
+        # NOTE: server must not shadow client's own attributes
+        if method_name.startswith(PRIVATE_OR_PROTECTED_PREFIX) or hasattr(type(self), method_name):
+            return
+
+        parameters = [param['name'] for param in description.get('params', [])]
+
+        def method_caller(*args, **kwargs):
+            if len(args) > len(parameters):
+                raise TypeError(f'{method_name}() takes at most {len(parameters)} positional arguments')
+
+            for parameter_name, argument in zip(parameters, args):
+                if parameter_name in kwargs:
+                    raise TypeError(f'{method_name}() got multiple values for argument {parameter_name!r}')
+
+                kwargs[parameter_name] = argument
+
+            return self._handle_request(method_name, **kwargs)
+
+        method_caller.__name__ = method_name
+        method_caller.__doc__ = description.get('doc')
+
+        self._dynamic_methods.add(method_name)
+        setattr(self, method_name, method_caller)
+
+    def close(self):
+        pass
+
+    def __enter__(self):
+        self.UPDATE_METHODS()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()

relst-1.1.0/relst/client/relst_flask_client.py

@@ -0,0 +1,32 @@
+import requests
+from typing import Tuple
+from .relst_client import RelstClient
+from ..protocol import DEFAULT_PROTOCOL
+
+
+class RelstFlaskClient(RelstClient):
+    """Client of RelstTextualServer, speaks json / xml / binary over http"""
+
+    _embed_method = False
+
+    def __init__(self, server_address: str, server_port: int, is_https: bool = False,
+                 protocol: str = DEFAULT_PROTOCOL, timeout: float = 30):
+        super().__init__(protocol)
+
+        requests_protocol = "https" if is_https else "http"
+        self.__request_prefix = f"{requests_protocol}://{server_address}:{server_port}"
+        self.__timeout = timeout
+        self.__session = requests.Session()
+
+    def _send(self, method_name: str, request: bytes) -> Tuple[int, bytes]:
+        response = self.__session.post(
+            f"{self.__request_prefix}/{method_name}",
+            data=request,
+            headers={'Content-Type': self._codec.content_type, 'Accept': self._codec.content_type},
+            timeout=self.__timeout,
+        )
+
+        return response.status_code, response.content
+
+    def close(self):
+        self.__session.close()

relst-1.1.0/relst/client/relst_socket_client.py

@@ -0,0 +1,61 @@
+import socket
+import threading
+from typing import Tuple
+from .relst_client import RelstClient
+from ..protocol import Frame, RelstProtocolError
+
+
+class RelstSocketClient(RelstClient):
+    """Client of RelstBinaryServer, keeps one tcp connection (thread-safe, calls are serialized)"""
+
+    def __init__(self, server_address: str, server_port: int, timeout: float = 30):
+        super().__init__('binary')
+
+        self.__address = (server_address, server_port)
+        self.__timeout = timeout
+        self.__socket = None
+        self.__lock = threading.Lock()
+
+    def _send(self, method_name: str, request: bytes) -> Tuple[int, bytes]:
+        with self.__lock:
+            try:
+                connection = self.__connection()
+                connection.sendall(request)
+
+                _, raw_response = Frame.read(lambda size: self.__read(connection, size))
+            except (OSError, RelstProtocolError):
+                self.__disconnect()
+                raise
+
+        # NOTE: binary frames carry their own kind, status is only informative
+        return 200, raw_response
+
+    def close(self):
+        with self.__lock:
+            self.__disconnect()
+
+    def __connection(self) -> socket.socket:
+        if self.__socket is None:
+            self.__socket = socket.create_connection(self.__address, timeout=self.__timeout)
+
+        return self.__socket
+
+    def __disconnect(self):
+        if self.__socket is not None:
+            self.__socket.close()
+            self.__socket = None
+
+    @staticmethod
+    def __read(connection: socket.socket, size: int) -> bytes:
+        chunks = []
+
+        while size > 0:
+            chunk = connection.recv(size)
+
+            if not chunk:
+                raise ConnectionError('server closed the connection')
+
+            chunks.append(chunk)
+            size -= len(chunk)
+
+        return b''.join(chunks)

relst-1.1.0/relst/client/relst_ui.py

@@ -0,0 +1,22 @@
+import eel
+from argparse import ArgumentParser
+from .relst_flask_client import RelstFlaskClient
+
+
+def main(args):
+    client = RelstFlaskClient(args.server_address, args.server_port)
+
+    @eel.expose
+    def handle_request(function_name, **function_args):
+        return client.handle_request(function_name, **function_args)
+
+    eel.init("frontend")
+    eel.start()
+
+
+if __name__ == "__main__":
+    args_parser = ArgumentParser("GUI-Client for relst-api server")
+    args_parser.add_argument("server_address", type=str, help='name or ip of relst-api server')
+    args_parser.add_argument("server_port", type=int, help='port of relst-api server')
+
+    main(args_parser.parse_args())

relst-1.1.0/relst/protocol/__init__.py

@@ -0,0 +1,38 @@
+from .codec import Codec
+from .json_codec import JsonCodec
+from .xml_codec import XmlCodec
+from .binary_codec import BinaryCodec, Frame, FrameHeader, FrameKind, ValueTag, FRAME_HEADER_SIZE
+from .errors import RelstProtocolError, RelstRemoteError
+from .values import to_plain
+
+
+CODECS = {codec.name: codec for codec in (JsonCodec(), XmlCodec(), BinaryCodec())}
+DEFAULT_PROTOCOL = 'json'
+
+
+def get_codec(protocol: str) -> Codec:
+    try:
+        return CODECS[protocol.lower()]
+    except (KeyError, AttributeError):
+        raise RelstProtocolError(f'unknown protocol {protocol!r}, expected one of {sorted(CODECS)}') from None
+
+
+def codec_from_content_type(content_type) -> Codec:
+    """
+    :brief: picks codec by http Content-Type (parameters like charset are ignored)
+    :except: RelstProtocolError for unsupported types
+    """
+
+    media_type = (content_type or '').split(';')[0].strip().lower()
+
+    if not media_type:
+        return CODECS[DEFAULT_PROTOCOL]
+
+    for codec in CODECS.values():
+        if media_type == codec.content_type:
+            return codec
+
+    if media_type in ('text/xml', 'text/json'):
+        return CODECS['xml' if media_type == 'text/xml' else 'json']
+
+    raise RelstProtocolError(f'unsupported content-type {media_type!r}')