Update

src/jsonrpc/__init__.py

@@ -11,86 +11,42 @@ from .exceptions import *
 log = logging.getLogger(__name__)
 
 
-class Method:
-    def __init__(self, function, middlewares=None, debug: bool = False):
-        self.function = function
-        self.middlewares = middlewares
-        self.debug = debug
-
-    def exec_function(self, query):
-        params = None
-        if 'params' in query:
-            params = query['params']
-            if self.debug:
-                log.error(params)
-        if params is None:
-            response = self.function()
-        elif isinstance(params, list):
-            response = self.function(*params)
-        elif isinstance(params, dict):
-            response = self.function(**params)
-        else:
-            raise InvalidParamsError(
-                id=query['id'],
-                message='Invalid params: {0}'.format(params)
-            )
-
-        return response
-
-    def __call__(self, query):
-        if isinstance(self.middlewares, list):
-            i = iter(self.middlewares)
-            onion = self.exec_function
-            while (handler := next(i, None)):
-                onion = handler(onion)
-            response = onion(query)
-            return response
-        elif callable(self.middlewares):
-            middleware = self.middlewares(self.exec_function)
-            response = middleware(query)
-            return response
-
-        response = self.exec_function(query)
-        return response
-
-    def __repr__(self):
-        return '<{}>'.format(self.function)
-
-
 class JSONRPC:
     """Основной класс JSON-RPC
     """
     def __init__(self, debug: bool = False):
-        self.methods = {}
+        self.__handlers = {}
         self.debug = debug
 
-    def method(self, name: str, middlewares=None):
+    def method(self, name: str):
         """Декоратор метода
         """
         assert len(name) > 0, 'Не указано имя метода'
 
-        def wrap(function):
+        def wrap(method):
-            method = Method(
+            self.__handlers[name] = method
-                function=function,
+            return method
-                middlewares=middlewares
-            )
-            self.methods[name] = method
-            return function
         return wrap
 
+    def register(self, name: str, handler):
+        """Регистратор обработчика
+        """
+        assert len(name) > 0, 'Не указано имя метода'
+        self.__handlers[name] = handler
+
     def description(self, name: str):
         """Описание процедуры
         """
-        if name not in self.methods:
+        if name not in self.__handlers:
             return None
-        method = self.methods[name]
+        handler = self.__handlers[name]
-        sig = signature(method.function)
+        sig = signature(handler)
         # for key in sig.parameters:
         #     print(sig.parameters[key].annotation)
         result = {
             'name': name,
-            'function': getattr(method.function, '__name__', None),
+            'handler': getattr(handler, '__name__', None),
-            'summary': getattr(method.function, '__doc__', None),
+            'summary': getattr(handler, '__doc__', None),
             'params': [
                 {'name': k, 'type': sig.parameters[k].annotation.__name__}
                 for k in sig.parameters
@@ -102,10 +58,10 @@ class JSONRPC:
     def example(self, name: str):
         """Пример
         """
-        if name not in self.methods:
+        if name not in self.__handlers:
             return None
-        method = self.methods[name]
+        handler = self.__handlers[name]
-        sig = signature(method.function)
+        sig = signature(handler)
 
         result = {
             "jsonrpc": "3.0",
@@ -145,17 +101,17 @@ class JSONRPC:
         if result:
             return result
         name = query['method']
-        if name not in self.methods:
+        if name not in self.__handlers:
             result = MethodNotFoundError(
                 message=f'Метод не найден: {name}',
                 id=query['id']
             )
             return result
 
-        method = self.methods[name]
+        handler = self.__handlers[name]
 
         try:
-            response = method(query)
+            response = handler(query)
         except JSONRPCError as e:
             log.error(traceback.format_exc())
             response = InternalError(
@@ -193,21 +149,20 @@ class JSONRPC:
         return result
 
     def __getitem__(self, key):
-        method = self.methods[key]
+        handler = self.__handlers[key]
-        return method.function
+        return handler
 
     def __iter__(self):
-        return iter(self.methods)
+        return iter(self.__handlers)
 
     def __len__(self):
-        return len(self.methods)
+        return len(self.__handlers)
 
-    def __setitem__(self, key, function, middlewares=None):
+    def __setitem__(self, key, handler):
-        method = Method(function=function, middlewares=middlewares)
+        self.__handlers[key] = handler
-        self.methods[key] = method
 
     def __delitem__(self, key):
-        del self.methods[key]
+        del self.__handlers[key]
 
     def __repr__(self):
-        return repr(self.methods)
+        return repr(self.__handlers)

src/jsonrpc/rpc.py

@@ -18,8 +18,8 @@ class RPC:
         self.__handlers = {}
         self.debug = debug
 
-    def register(self, name: str):
+    def method(self, name: str):
-        """Регистратор обработчика
+        """Декоратор метода
         """
         assert len(name) > 0, 'Не указано имя метода'
 
@@ -28,19 +28,25 @@ class RPC:
             return handler
         return wrap
 
+    def register(self, name: str, handler):
+        """Регистратор обработчика
+        """
+        assert len(name) > 0, 'Не указано имя метода'
+        self.__handlers[name] = handler
+
     def description(self, name: str):
         """Описание процедуры
         """
         if name not in self.__handlers:
             return None
         handler = self.__handlers[name]
-        sig = signature(method.function)
+        sig = signature(handler)
         # for key in sig.parameters:
         #     print(sig.parameters[key].annotation)
         result = {
             'name': name,
-            'function': getattr(method, '__name__', None),
+            'handler': getattr(handler, '__name__', None),
-            'summary': getattr(method, '__doc__', None),
+            'summary': getattr(handler, '__doc__', None),
             'params': [
                 {'name': k, 'type': sig.parameters[k].annotation.__name__}
                 for k in sig.parameters