ab_engine 0.1.9__tar.gz → 0.2.0__tar.gz

{ab_engine-0.1.9 → ab_engine-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab_engine
-Version: 0.1.9
+Version: 0.2.0
 Summary: Library of standard modules
 Author-email: Andrew Bulatov <BulatovAndrew@gmail.com>
 License-Expression: MIT
@@ -655,6 +655,7 @@ async def sql(query:str, *args, **kwargs):
 Передавать опции можно только в конце списка args, после позиционных параметров, либо вместо них.
 В библиотеке реализованы следующие опции:
 * DB    - служит для передачи соединения в функцию sql. Передается как DB("строка соединения").
+* NOTICE - то же, что DB, но запросы с такой опцией возвращают как результат список сообщений нотификации
 * TIMEOUT- устанавливает максимальное время в секундах на выполнение запроса. точность - до сотых секунды. 
         По умолчанию вызывает ошибку, при превышении времени ожидания. TIMEOUT(time_sec:float, raise_error:bool=True)
 * DICT   - Указывает, что результат следует вернуть как список dict (RowFactory.DICT). Установлена по умолчанию
@@ -1217,7 +1218,65 @@ if __name__ == '__main__':
 
 ### Регистрация методов
 
-Методы RPC регистрируются c помощью декоратора:
+Методы RPC регистрируются функцией register_rpc_list либо c помощью декоратора register_rpc, который также можно использовать как функцию.
+
+Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход парамектры defs и self.
+* **defs** - содержит список или словарь с описаниями
+* **self** - необязательный параметр, в котором передается модуль или объект из которого будут регистрироваться функции. если в self ничего не передано, то будут регистрироваться функции из модуля, в котором вызвана register_rpc_list.
+
+список или словарь с орписаниями содержит элементы следующей структуры:
+* **name**: имя функции в API (не нужно и игнорируется, если описание передается в словаре)
+* **function**: имя реально вызываемой функции, если оно отличается от name
+* **sql**: запрос sql, реализующий функцию, если передан sql, то не нужно передавать function и type
+* **help**: описание функции. если не задано - берется из функции
+* **type**: тип функции
+  * **self** - функция из объекта, переданного в параметре self
+  * **py**   - функция из плагина python
+  * **db**   - функция БД
+* **ext**: дополнительные параметры регистрации, если нужны. для sql это могут быть опции или их имена
+
+для функций с типом **self** для которых name==function возможна запись:
+***имя_функции: self***
+
+Пример списка для регистрации:
+```python
+from ab_engine import register_rpc_list, call_rpc
+
+def hello():
+    return "Здравствуй мир!"
+
+register_rpc_list({
+    "hello":"self", 
+    "hello2":{
+        "sql":"""
+        do $$
+        declare
+          nm varchar;
+        begin
+          nm = $name::varchar;
+          raise notice 'Hello % !!', nm;
+        end $$
+        """,
+        "ext": ["NOTICE","ONE"]
+    },
+    "set":{
+        "sql":"set $key $value",
+        "ext":"DB(valkey)",
+        "help": "устанавливает значение ключа key равным value"
+    },
+    "get":{
+        "sql":"get $key",
+        "ext":"DB(valkey)",
+        "help": "возвращает значение ключа key"
+    }
+})
+
+async def test():
+    await call_rpc("set", key="test", value=1234)
+```
+
+
+Регистрация с помощью декоратора: 
 ```python
 from ab_engine import register_rpc
 from ab_engine.db import ONE

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/__init__.py

@@ -1,4 +1,4 @@
 from .env import Config, LogLevel
 from .env.timer import TimerInterval
-from .rpc import register as register_rpc, call_rpc, call_json
+from .rpc import register as register_rpc, call_rpc, call_json, register_list as register_rpc_list
 from .error import raise_error, load_errors, error

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/db/driver.py

@@ -168,7 +168,8 @@ class Driver(ABC):
         if callback:=kwargs.get("__PARAM_CALLBACK_GETTER"):
             del kwargs["__PARAM_CALLBACK_GETTER"]
         qs = None
-        for x in query.split("$"):
+
+        for x in query.replace("$$", "🗿").split("$"):
             if qs is None:
                 qs = x
                 continue
@@ -195,7 +196,7 @@ class Driver(ABC):
             qs += f"{self.var_to_sql(n, x)}{x}"
             
         if qs:
-            query = qs
+            query = qs.replace("🗿", "$$")
 
         return query
 

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/db/driver_valkey.py

@@ -216,4 +216,40 @@ class Driver(BaseDriver):
             await super().rollback()
 
     async def table_struct(self, table_name) -> dict:
-        return {}
+        return {}
+
+    async def parse_query(self, query, *args, **kwargs):
+        if callback:=kwargs.get("__PARAM_CALLBACK_GETTER"):
+            del kwargs["__PARAM_CALLBACK_GETTER"]
+        qs = None
+
+        for x in query.split("$"):
+            if qs is None:
+                qs = x
+                continue
+            n, p = '', 0
+            if str(x[p]).isdigit():
+                while p < len(x) and x[p].isdigit():
+                    n += x[p]
+                    p += 1
+                n = int(n) - 1
+                if n < 0 or n >= len(args):
+                    raise AttributeError(f"Attribute with index {n} is not exists")
+                n = args[n]
+            else:
+                while p < len(x) and not(x[p].isspace() or x[p] in "(:,)"):
+                    n += x[p]
+                    p += 1
+                if n in kwargs:
+                    n = kwargs[n]
+                elif callback:
+                    n = callback[n]
+                else:
+                    raise AttributeError(f"Attribute with name {n} is not exists")
+            x = x[p:]
+            qs = f"{qs}{n}{x}"
+
+        if qs:
+            query = qs
+
+        return query

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/db/option.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from importlib.machinery import SourceFileLoader
 from json5 import loads
 from asyncio import BoundedSemaphore, wait_for, TimeoutError, sleep
-from ..error import raise_error
+from ..error import error
 from inspect import iscoroutinefunction
 from typing import Callable
 from gc import collect as garbage_collect
@@ -66,6 +66,25 @@ class Option(ABC):
         """
         return ret_data, row_factory
 
+    @staticmethod
+    def create(option:str, *args, **kwargs):
+
+        def find(parent_cls, name):
+            for x in parent_cls.__subclasses__():
+                if x.__name__ == name:
+                    return x
+                else:
+                    x = find(x, name)
+                    if x:
+                        return x
+            return None
+
+        x = find(Option, option)
+        if x is None:
+            raise error("CLASS_NOT_FOUND", name=option)
+        return x(*args, **kwargs)
+
+
 _set_is_option(Option.is_option)
 
 class ALL(Option):
@@ -98,7 +117,7 @@ class DB(Option):
             try:
                 _check_cfg()
             except Exception as e:
-                raise_error("NA_DB", connection=str(e))
+                raise error("NA_DB", connection=str(e))
             connection_string = _CFG_.db_connection(connection_string)
         driver_name, connection_string = connection_string.split("://", 1)
 
@@ -216,6 +235,22 @@ class TIMEOUT(Option):
                 raise e
             return None
 
+class NOTICE(DB):
+
+    def __init__(self, connection_string: str=""):
+        self._notify = []
+        super().__init__(connection_string, self._notify)
+
+    @classproperty
+    def can_process(cls):
+        return True
+
+    async def process(self, ret_data=None, connection=None, row_factory=None):
+        ret = self._notify.copy()
+        self._notify.clear()
+        return ret, None
+
+
 class DICT(Option):
     """
     Указывает, что результат следует вернуть как список dict (по умолчанию)
@@ -260,6 +295,10 @@ class ONE(ROW):
     async def process(ret_data, connection, row_factory):
         if ret_data is None or isinstance(ret_data, int):
             return ret_data, None
+        elif row_factory is None and isinstance(ret_data, list):
+            if len(ret_data) == 0:
+                return None
+            return ret_data[0], RowFactory.ANY
         match row_factory:
             case RowFactory.TUPLE:
                 return ret_data[0], None
@@ -286,7 +325,7 @@ class JSON(ONE):
         elif isinstance(ret_data, str):
             return loads(ret_data), None
         else:
-            raise_error("NOT_CONV_DICT_LIST", data=ret_data)
+            raise error("NOT_CONV_DICT_LIST", data=ret_data)
 
 class ROLLBACK(Option):
     """
@@ -325,7 +364,7 @@ class PAGE(Option):
         :param offset: смещение от начала
         """
         if not(isinstance(limit, int) and isinstance(offset, int)) or limit < 0 or offset < 0:
-            raise_error("BAD_LIMIT_OFFSET")
+            raise error("BAD_LIMIT_OFFSET")
         self._limit = limit
         self._offset = offset
 
@@ -361,7 +400,7 @@ class CALLBACK(Option):
 
     def __getitem__(self, item):
         if self._attrs is None:
-            raise_error("ATTR_NOT_FOUND", name=item)
+            raise error("ATTR_NOT_FOUND", name=item)
         return self._attrs[item]
 
 

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/db/processor.py

@@ -1,6 +1,6 @@
-from .option import Option, DB, TIMEOUT, PAGE, CALLBACK, ITERATOR, RAW
+from .option import Option, DB, TIMEOUT, PAGE, CALLBACK, ITERATOR, RAW, NOTICE
 from .driver import RowFactory
-from ..error import raise_error
+from ..error import error
 
 CONNECTION:str = ""
 
@@ -19,38 +19,38 @@ async def sql(query:str, *args, **kwargs):
             if one_row is None and arg.one_row is not None:
                 one_row = arg
             elif one_row and arg.one_row is not None and one_row.one_row!=arg.one_row:
-                raise_error("NEQ_ROWS", src1=one_row.__class__.__name__, src2=arg.__class__.__name__)
+                raise error("NEQ_ROWS", src1=one_row.__class__.__name__, src2=arg.__class__.__name__)
             if row_factory is None or row_factory.row_factory == RowFactory.ANY:
                 row_factory = arg
             elif row_factory and arg.row_factory != RowFactory.ANY:
-                raise_error("DEF_STR_FABRIC", src = row_factory.__class__.__name__)
+                raise error("DEF_STR_FABRIC", src = row_factory.__class__.__name__)
+            if arg in (DB, NOTICE):
+                arg = arg()
+            if isinstance(arg, DB) and db is None:
+                db = arg
             if arg.can_process:
                 process.append(arg)
                 continue
-            if arg == DB:
-                arg = DB()
-            if isinstance(arg, DB) and db is None:
-                db = arg
-            elif isinstance(arg, CALLBACK) and callback is None:
+            if isinstance(arg, CALLBACK) and callback is None:
                 callback = arg
             elif isinstance(arg, DB):
-                raise_error("DB_ALRDY_DEF")
+                continue #raise error("DB_ALRDY_DEF")
             elif isinstance(arg, PAGE) and page is None:
                 page = arg
             elif isinstance(arg, PAGE):
-                raise_error("PAGE_ALRDY_DEF")
+                raise error("PAGE_ALRDY_DEF")
             elif isinstance(arg, TIMEOUT) and tm is None:
                 tm = arg
             elif isinstance(arg, TIMEOUT):
-                raise_error("TIMEOUT_ALRDY_DEF")
+                raise error("TIMEOUT_ALRDY_DEF")
             elif arg == ITERATOR:
                 itr = ITERATOR()
             elif isinstance(arg, ITERATOR):
                 itr = arg
-            elif arg == RAW:
+            elif arg == RAW or isinstance(arg, RAW):
                 parse = False
         elif process:
-            raise_error("PMT_BEF_OPT")
+            raise error("PMT_BEF_OPT")
     if process:
         args = args[:process.pop(0)]
     if db is None:
@@ -61,17 +61,16 @@ async def sql(query:str, *args, **kwargs):
     await db.garbage_collect(False)
     one_row = one_row.one_row if one_row else False
     row_factory = row_factory.row_factory if row_factory and row_factory.row_factory != RowFactory.ANY else RowFactory.DICT
-    if callback:
-        kwargs["__PARAM_CALLBACK_GETTER"] = callback
     if parse:
         query = await db.connection.parse_query(query, *args, **kwargs)
     if page:
         query = await page(db.connection, query)
     if callback is not None:
+        kwargs["__PARAM_CALLBACK_GETTER"] = callback
         query = await callback(query)
     if itr:
         if page:
-            raise_error("PAGE_ITERATOR")
+            raise error("PAGE_ITERATOR")
         return itr(query, db, row_factory, process)
     try:
         if tm is None:

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/env/config.py

@@ -451,7 +451,9 @@ class Config:
 
         if isinstance(msg, Exception):
             level = LogLevel.ERROR
+            sql = False
         else:
+            sql = level == LogLevel.SQL
             level = self._parse_log_level(level)
             msg = str(msg)
         if level.value < self.log_level.value:
@@ -479,15 +481,15 @@ class Config:
                     info = log_to.findCaller(stacklevel=lvl)
                     p = str(Path(__file__).parent.parent)
                     while info[0].startswith(p):
-                         lvl += 1
-                         x = log_to.findCaller(stacklevel=lvl)
-                         if '/venv/' in x[0]:
-                             break
-                         elif not x[0].startswith(p):
-                             info = x
-                             break
-                         else:
-                             info = x
+                        lvl += 1
+                        x = log_to.findCaller(stacklevel=lvl)
+                        if '/venv/' in x[0]:
+                            break
+                        elif not x[0].startswith(p):
+                            info = x
+                            break
+                        else:
+                            info = x
                 else:
                     info = log_to.findCaller(stacklevel=kwargs.get('stacklevel', 2))
 
@@ -510,6 +512,8 @@ class Config:
 
             params["msg"] = f"{msg}"
             info = log_to.makeRecord(**params)
+            if sql:
+                info.levelname = "SQL"
             log_to.handle(info)
         except Exception as e:
             # Больше вывести некуда - выводим на стандартный вывод

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/error.yaml

@@ -116,4 +116,8 @@
   class: RuntimeError
 - code: BAD_RPC_METHOD
   msg: Имя метода содержит недопустимое значение
-  class: ValueError
+  class: ValueError
+- code: CLASS_NOT_FOUND
+  msg: Класс {name} не найден
+- code: NOT_FOUND_)
+  msg: Нет закрывающей скобки {context}

ab_engine-0.2.0/ab_engine/rpc/__init__.py

@@ -0,0 +1,2 @@
+from .rpc import register, call_rpc, register_list
+from .json_rpc import call_json

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine/rpc/rpc.py

@@ -3,9 +3,10 @@ from os import sep as file_sep
 from .fnc import *
 from ..error import error
 from ..env import Config, DB_ENV
-from sys import argv as sys_argv
+from ..db.option import Option
+from sys import argv as sys_argv, modules
 from pathlib import Path
-
+import inspect
 
 def _split_module_fnc(module_name: str):
     # можно передать в пути реальное имя функции после :
@@ -142,4 +143,116 @@ async def call_rpc(name_of_rpc_method_for_call, current_rpc_environment_for_call
     except Exception as e:
         if current_rpc_environment_for_call.in_transaction:
             await current_rpc_environment_for_call.rollback()
-        raise e
+        raise e
+
+def split_params(params:str)->list:
+    ret, s, q, lq = [], "", "", False
+
+    def add_ret():
+        nonlocal ret, s, lq
+        if lq:
+            ret.append(s)
+            lq = False
+            return
+        elif s == "":
+            ret.append(None)
+            return
+        elif s.isnumeric():
+            try:
+                s = int(s)
+            except Exception as e:
+                s = float(s)
+            ret.append(s)
+            return
+        lwr = s.lower()
+        if s == "true":
+            ret.append(True)
+        elif s == "false":
+            ret.append(False)
+        else:
+            ret.append(s)
+
+    for ch in params:
+        if ch == q:
+            q = ""
+            lq = True
+        elif ch in ('"',"'"):
+            q = ch
+        elif ch == "," and q == "":
+            add_ret()
+            s = ""
+        else:
+            s += ch
+
+    if s:
+        add_ret()
+    return ret
+
+
+def register_list(defs:list | dict, self=None)->None:
+    """
+    Регистрирует для RPC функции, переданные в списке или в словаре.
+    в случае, если описания передаются в словаре, то ключ словаря это имя функции в API
+    если описания передаются списком, то имя функции передается в атрибуте name
+    :param defs: писок или словарь с описанием функций, элементыы которого имеют следующую структуру:
+        name: имя функции в API (не нужно, если описание передается в словаре)
+        function: имя реально вызываемой функции, если оно отличается от name
+        sql: запрос sql, реализующий функцию, если передан sql, то не нужно передавать function и type
+        help: описание функции. если не задано - берется из функции
+        type: тип функции
+            self - функция из объекта, переданного в параметре self (см. ниже)
+            py   - функция из плагина python
+            db   - функция БД
+        для функций с типом self для которых name==function возможна запись:
+            имя_функции: self
+        ext: дополнительные параметры регистрации, если нужны. для sql это могут быть опции или их имена
+    :param self: объект или модуль, из которого берем функции с типом self. если не передан,
+            то из модуля, откуда вызвана данная функция
+    """
+    if self is None:
+        frame = inspect.currentframe().f_back
+        x = frame.f_globals.get('__name__')
+        self = modules.get(x)
+    if isinstance(defs, dict):
+        ...
+    elif isinstance(defs, list):
+        defs = {x["name"]:x for x in defs}
+    else:
+        raise error("BAD_RPC_FORMAT")
+    for x in defs:
+        fnc = defs[x]
+        if "sql" in fnc:
+            if "ext" in fnc:
+                fn = []
+                if isinstance(fnc["ext"], str):
+                    fnc["ext"] = [fnc["ext"],]
+                for opt in fnc["ext"]:
+                    if not isinstance(opt, str):
+                        fn.append(opt)
+                        continue
+                    if "(" in opt:
+                        opt, params = opt.split("(",1)
+                        params = params.strip()
+                        if not params.endswith(")"):
+                            raise error("NOT_FOUND_)", context=f"ext: {fnc['ext']}")
+                        params = split_params(params[:-1].strip())
+                        opt = Option.create(opt, *params)
+                    else:
+                        opt = Option.create(opt)
+                    fn.append(opt)
+                fn = tuple([fnc["sql"]] + fn)
+            else:
+                fn = fnc["sql"]
+            SqlFnc(x, fn, help=fnc.get('help'))
+        elif fnc == "self":
+            fn = getattr(self, x)
+            PythonFnc(x, fn)
+        else:
+            match fnc.get("type", "db"):
+                case "db":
+                    SqlFnc(x, f"\JSON {fnc['function']}(JSONB)", help=fnc.get('help'))
+                case "self":
+                    fn = getattr(self, fnc['function'])
+                    PythonFnc(x, fn, help = fnc.get('help') )
+                case _:
+                    register(x, fnc["function"], help = fnc.get('help'))

{ab_engine-0.1.9 → ab_engine-0.2.0}/ab_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab_engine
-Version: 0.1.9
+Version: 0.2.0
 Summary: Library of standard modules
 Author-email: Andrew Bulatov <BulatovAndrew@gmail.com>
 License-Expression: MIT
@@ -655,6 +655,7 @@ async def sql(query:str, *args, **kwargs):
 Передавать опции можно только в конце списка args, после позиционных параметров, либо вместо них.
 В библиотеке реализованы следующие опции:
 * DB    - служит для передачи соединения в функцию sql. Передается как DB("строка соединения").
+* NOTICE - то же, что DB, но запросы с такой опцией возвращают как результат список сообщений нотификации
 * TIMEOUT- устанавливает максимальное время в секундах на выполнение запроса. точность - до сотых секунды. 
         По умолчанию вызывает ошибку, при превышении времени ожидания. TIMEOUT(time_sec:float, raise_error:bool=True)
 * DICT   - Указывает, что результат следует вернуть как список dict (RowFactory.DICT). Установлена по умолчанию
@@ -1217,7 +1218,65 @@ if __name__ == '__main__':
 
 ### Регистрация методов
 
-Методы RPC регистрируются c помощью декоратора:
+Методы RPC регистрируются функцией register_rpc_list либо c помощью декоратора register_rpc, который также можно использовать как функцию.
+
+Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход парамектры defs и self.
+* **defs** - содержит список или словарь с описаниями
+* **self** - необязательный параметр, в котором передается модуль или объект из которого будут регистрироваться функции. если в self ничего не передано, то будут регистрироваться функции из модуля, в котором вызвана register_rpc_list.
+
+список или словарь с орписаниями содержит элементы следующей структуры:
+* **name**: имя функции в API (не нужно и игнорируется, если описание передается в словаре)
+* **function**: имя реально вызываемой функции, если оно отличается от name
+* **sql**: запрос sql, реализующий функцию, если передан sql, то не нужно передавать function и type
+* **help**: описание функции. если не задано - берется из функции
+* **type**: тип функции
+  * **self** - функция из объекта, переданного в параметре self
+  * **py**   - функция из плагина python
+  * **db**   - функция БД
+* **ext**: дополнительные параметры регистрации, если нужны. для sql это могут быть опции или их имена
+
+для функций с типом **self** для которых name==function возможна запись:
+***имя_функции: self***
+
+Пример списка для регистрации:
+```python
+from ab_engine import register_rpc_list, call_rpc
+
+def hello():
+    return "Здравствуй мир!"
+
+register_rpc_list({
+    "hello":"self", 
+    "hello2":{
+        "sql":"""
+        do $$
+        declare
+          nm varchar;
+        begin
+          nm = $name::varchar;
+          raise notice 'Hello % !!', nm;
+        end $$
+        """,
+        "ext": ["NOTICE","ONE"]
+    },
+    "set":{
+        "sql":"set $key $value",
+        "ext":"DB(valkey)",
+        "help": "устанавливает значение ключа key равным value"
+    },
+    "get":{
+        "sql":"get $key",
+        "ext":"DB(valkey)",
+        "help": "возвращает значение ключа key"
+    }
+})
+
+async def test():
+    await call_rpc("set", key="test", value=1234)
+```
+
+
+Регистрация с помощью декоратора: 
 ```python
 from ab_engine import register_rpc
 from ab_engine.db import ONE

{ab_engine-0.1.9 → ab_engine-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ab_engine"
-version = "0.1.9"
+version = "0.2.0"
 description = "Library of standard modules"
 authors = [{name = "Andrew Bulatov", email = "BulatovAndrew@gmail.com"}]
 license = "MIT"

{ab_engine-0.1.9 → ab_engine-0.2.0}/readme.md

@@ -641,6 +641,7 @@ async def sql(query:str, *args, **kwargs):
 Передавать опции можно только в конце списка args, после позиционных параметров, либо вместо них.
 В библиотеке реализованы следующие опции:
 * DB    - служит для передачи соединения в функцию sql. Передается как DB("строка соединения").
+* NOTICE - то же, что DB, но запросы с такой опцией возвращают как результат список сообщений нотификации
 * TIMEOUT- устанавливает максимальное время в секундах на выполнение запроса. точность - до сотых секунды. 
         По умолчанию вызывает ошибку, при превышении времени ожидания. TIMEOUT(time_sec:float, raise_error:bool=True)
 * DICT   - Указывает, что результат следует вернуть как список dict (RowFactory.DICT). Установлена по умолчанию
@@ -1203,7 +1204,65 @@ if __name__ == '__main__':
 
 ### Регистрация методов
 
-Методы RPC регистрируются c помощью декоратора:
+Методы RPC регистрируются функцией register_rpc_list либо c помощью декоратора register_rpc, который также можно использовать как функцию.
+
+Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход парамектры defs и self.
+* **defs** - содержит список или словарь с описаниями
+* **self** - необязательный параметр, в котором передается модуль или объект из которого будут регистрироваться функции. если в self ничего не передано, то будут регистрироваться функции из модуля, в котором вызвана register_rpc_list.
+
+список или словарь с орписаниями содержит элементы следующей структуры:
+* **name**: имя функции в API (не нужно и игнорируется, если описание передается в словаре)
+* **function**: имя реально вызываемой функции, если оно отличается от name
+* **sql**: запрос sql, реализующий функцию, если передан sql, то не нужно передавать function и type
+* **help**: описание функции. если не задано - берется из функции
+* **type**: тип функции
+  * **self** - функция из объекта, переданного в параметре self
+  * **py**   - функция из плагина python
+  * **db**   - функция БД
+* **ext**: дополнительные параметры регистрации, если нужны. для sql это могут быть опции или их имена
+
+для функций с типом **self** для которых name==function возможна запись:
+***имя_функции: self***
+
+Пример списка для регистрации:
+```python
+from ab_engine import register_rpc_list, call_rpc
+
+def hello():
+    return "Здравствуй мир!"
+
+register_rpc_list({
+    "hello":"self", 
+    "hello2":{
+        "sql":"""
+        do $$
+        declare
+          nm varchar;
+        begin
+          nm = $name::varchar;
+          raise notice 'Hello % !!', nm;
+        end $$
+        """,
+        "ext": ["NOTICE","ONE"]
+    },
+    "set":{
+        "sql":"set $key $value",
+        "ext":"DB(valkey)",
+        "help": "устанавливает значение ключа key равным value"
+    },
+    "get":{
+        "sql":"get $key",
+        "ext":"DB(valkey)",
+        "help": "возвращает значение ключа key"
+    }
+})
+
+async def test():
+    await call_rpc("set", key="test", value=1234)
+```
+
+
+Регистрация с помощью декоратора: 
 ```python
 from ab_engine import register_rpc
 from ab_engine.db import ONE

ab_engine-0.1.9/ab_engine/rpc/__init__.py

@@ -1,2 +0,0 @@
-from .rpc import register, call_rpc
-from .json_rpc import call_json