relst 1.1.0__py3-none-any.whl

relst/__init__.py

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

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/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/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/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/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/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}')