ab_engine 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab_engine
-Version: 0.2.0
+Version: 0.2.1
 Summary: Library of standard modules
 Author-email: Andrew Bulatov <BulatovAndrew@gmail.com>
 License-Expression: MIT
@@ -9,7 +9,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: json5>=0.12.0
 Requires-Dist: psycopg>=3.2.9
-Requires-Dist: pyaml>=25.7.0
+Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: toml>=0.10.2
 
 Библиотека стандартных модулей
@@ -377,12 +377,39 @@ logging:
 
 Можно описывать драйвера к другим БД. Для того чтобы использовать собственный драйвер, можно добавить класс драйвера
 в словарь DRIVER_CLASSES, который находится в модуле ab_engine/db/option, либо положить драйвер в каталог драйверов.
+
 Пример драйвера в DRIVER_CLASSES:
+```python
+from ab_engine.db import sql, ONE, DB
+from ab_engine.db.option import DRIVER_CLASSES
+from ab_engine.db.driver_postgresql import Driver
+import asyncio
+
+class MyPgDriver(Driver):
+
+    async def begin(self):
+        await super().begin()
+        print("BEGIN TRANSACTION", flush=True)
+
+    async def rollback(self):
+        await super().rollback()
+        print("END TRANSACTION", flush=True)
 
-необходимости использовать собственный драйвер, можно в строке соединения в 
+DRIVER_CLASSES["my_pg"] = MyPgDriver
+
+async def main():
+    x = await sql("select version();", ONE, DB("my_pg://postgres:postgres@localhost:5432/postgres"))
+    print(x)
+    await DB.garbage_collect()
+
+if __name__ == '__main__':
+    asyncio.run(main())
+```
+
+При необходимости задать путь поиска с собственным драйвером, можно в строке соединения, в 
 фигурных скобках задать параметр **driver_path**, определяющий путь для поиска драйвера.
 
-Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр db_driver_path в defaults конфигурации.
+Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр **db_driver_path** в секции конфигурации **defaults**.
 
 Если приложению требуется только одна строка соединения, то ее можно задать в переменной database, например:
 
@@ -390,7 +417,7 @@ logging:
 database: postgresql://localhost:5432/postgres?user=postgres&password=postgres
 ```
 
-Также можно задать несколько соединений, если использовать database как секцию:
+Чтобы задать несколько соединений, нужно использовать database как секцию:
 
 ```toml
 [database]
@@ -401,7 +428,7 @@ mydb = "postgresql://localhost:5432/mydb?user=postgres&password=postgres"
 database = "test"
 ```
 
-При этом, в секции defaults можно задать имя соединения БД, которое будет использоваться по умолчанию (см пример выше)
+При этом, в секции **defaults** можно задать имя соединения БД, которое будет использоваться по умолчанию. Для этого следует задать значение **database** в секции **defaults**.
 
 Строка соединения с БД имеет следующую структуру:
 <имя_драйвера>**://**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
@@ -418,10 +445,15 @@ database = "test"
     который ограничит максимальное количество таких соединений. Т.е. по достижении данного числа соединений система
     не станет выполнять очередную команду до тех пор, пока не освободится одно из текущих соединений с БД.
 
-Для некоторых драйверо, например, для встроенного драйвера posstgresql строка сооединения с БД 
+Для некоторых драйверов, например, для встроенного драйвера posstgresql строка сооединения с БД 
 может иметь альтернативную структуру:
 
-<имя_драйвера>**://**<имя пользователя>**:**<пароль>**"**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
+<имя_драйвера>**://**<имя пользователя>**:**<пароль>**@**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
+
+Если нужно установить **peer** соединение c БД postgresql, то в строке соединения достаточно передать имя БД и доп. параметры (если нужно). Например:
+```python
+x = await sql("select version()", ONE, DB("postgresql://postgres?application_name=test"))
+```
 
 Драйвер БД должен иметь имя driver_<имя в строке соединения>.py и предоставлять следующий контракт:
 
@@ -1220,7 +1252,7 @@ if __name__ == '__main__':
 
 Методы RPC регистрируются функцией register_rpc_list либо c помощью декоратора register_rpc, который также можно использовать как функцию.
 
-Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход парамектры defs и self.
+Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход параметры defs и self.
 * **defs** - содержит список или словарь с описаниями
 * **self** - необязательный параметр, в котором передается модуль или объект из которого будут регистрироваться функции. если в self ничего не передано, то будут регистрироваться функции из модуля, в котором вызвана register_rpc_list.
 

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

@@ -1,6 +1,6 @@
 from enum import Enum
 from json import dumps
-from datetime import datetime
+from datetime import datetime, time
 from abc import ABC, abstractmethod
 from collections import namedtuple
 from typing import Optional
@@ -158,7 +158,7 @@ class Driver(ABC):
         elif isinstance(var, dict):
             var = dumps(var, ensure_ascii=False).replace("'", "''")
             return reencode(var)
-        elif isinstance(var, datetime):
+        elif isinstance(var, (datetime, time)):
             return f" '{var}'"
         else:
             return f" {var}"

{ab_engine-0.2.0 → ab_engine-0.2.1}/ab_engine/db/driver_sqlite.py

@@ -19,7 +19,11 @@ _Info = namedtuple("Info", ["column_name", "data_type", "is_nullable", "characte
                        "numeric_precision", "numeric_scale", "column_default", "autoincrement", "pk"])
 
 def _field_ifo_tuples(fields, str_fields):
-    str_fields = str_fields["sql"].split("\n", 1)[1][:-1].strip().split("\n")
+    str_fields = str_fields["sql"].split("\n", 1)
+    if len(str_fields) > 1:
+        str_fields = str_fields[1][:-1].strip().split("\n")
+    else:
+        str_fields = []
     str_def = {}
     for x in str_fields:
         n, x = x.strip().split(" ", 1)
@@ -30,7 +34,7 @@ def _field_ifo_tuples(fields, str_fields):
             sz = int(sz)
         else:
             sz = None
-        ai = str_def[row["name"]]
+        ai = str_def.get(row["name"],[])
         fields[n] = _Info(column_name=row["name"], data_type=row["type"].lower(), character_maximum_length=sz,
                           column_default=row["dflt_value"], is_nullable=row["notnull"] == 0 and row["pk"] == 0,
                           autoincrement=" autoincrement" in ai, pk=row["pk"],

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

@@ -126,11 +126,15 @@ class DB(Option):
         driver = DRIVER_CLASSES.get(driver_name)
         driver_path = None
         if conn_params:
-            conn_params = conn_params[:-1].split("&")
+            conn_params = conn_params[:-1]
+            mono_params = [x for x in conn_params.split("&") if "=" not in x ]
+            conn_params = {x[0].strip():x[1].strip() for x in [x.split("=", 1) for x in conn_params.split("&") if "=" in x]}
             if "driver_path" in conn_params:
                 driver_path = conn_params["driver_path"]
                 del conn_params["driver_path"]
-            conn_params = "?" + "&".join(conn_params)
+            conn_params = "?" + "&".join([f"{x}={conn_params[x]}" for x in conn_params])
+            if mono_params:
+                conn_params +="&" + "&".join(mono_params)
         connection_string += conn_params
         if driver is None:
             if driver_path is None and _CFG_ and _CFG_.initialized:

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

@@ -61,12 +61,13 @@ 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 is not None:
+        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:

{ab_engine-0.2.0 → ab_engine-0.2.1}/ab_engine/db/table.py

@@ -193,7 +193,7 @@ class Field:
             q = f"{q} where {self.table._filter}"
         ret = await sql(q, self.table._db, ONE)
         if self.table._auto_close_conn:
-            self.table._db.rollback()
+            await self.table._db.connection.rollback()
         return ret
 
     async def min(self):
@@ -648,7 +648,7 @@ class EnvTable(Table):
 
     @classmethod
     async def create(cls, table_name, env, page_size=100, async_delay=0.0001):
-        table_struct = await env.sql("\d "+table_name)
+        table_struct = await env.sql(r"\d "+table_name)
         if not table_struct:
             raise_error("NA_TABLE", name=table_name)
         t = cls(table_struct, env, page_size, async_delay)

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

@@ -10,7 +10,7 @@ import logging as LOG
 from enum import Enum
 from .timer import TimerList
 from ..class_tools import classproperty
-from ..error import raise_error, error_msg
+from ..error import error, error_msg
 import asyncio
 
 
@@ -60,7 +60,7 @@ def typed_val(key, values: dict):
             case 'STR)':
                 return str(v), key
             case 'FLOAT)':
-                return float(t), key
+                return float(v), key
             case _:
                 return v
     return v, key
@@ -74,6 +74,10 @@ def from_env(key:str, key_map:dict):
         eval_key = "x" + "".join(eval_key)
     else:
         eval_key = f"x['{key}']"
+
+    if any(char in eval_key for char in ("+", "-", "*", "/", "(", ")", "%", " ")):
+        raise error("BAD_KEY", key=eval_key)
+
     node = eval(eval_key, {"x": Config._settings}) if key else Config._settings[key]
     node.update(ret)
 
@@ -114,11 +118,11 @@ class Config:
                 case ".toml":
                     return toml_load(data)
                 case _:
-                    raise_error("BAD_FORMAT", format_name=fn)
+                    raise error("BAD_FORMAT", format_name=fn)
 
         self._log_level = LogLevel.INFO
         if path is None:
-            raise_error("BAD_CONFIG_PATH")
+            raise error("BAD_CONFIG_PATH")
         elif isinstance(path, dict):
             Config._settings = path
         elif isinstance(path, str):
@@ -133,7 +137,9 @@ class Config:
                     if isinstance(dest, dict):
                         dest.update(item)
                     else:
-                        data[x] = item
+                        Config._settings[x] = item
+        else:
+            raise error("BAD_CONFIG_TYPE")
 
         if not Config._settings:
             Config._settings = {}
@@ -145,6 +151,7 @@ class Config:
                 f = Config._settings.get(x)
                 if isinstance(f, str):
                     Config._settings[x] = load(f)
+        self.__log_timers = {}
         if "logging" in Config._settings:
             self._logger = ...
             if self.logger:
@@ -262,7 +269,7 @@ class Config:
 
     def __getattr__(self, item):
         if not(item in Config._settings):
-            raise_error("ATTR_NOT_FOUND", name=item)
+            raise error("ATTR_NOT_FOUND", name=item)
         return Config._settings[item]
 
     @property
@@ -359,7 +366,7 @@ class Config:
 
         hndl = self.logging["handler"]["class"]
         for x in LOG.Handler.__subclasses__():
-            if x.__name__ == self.logging["handler"]:
+            if x.__name__ == hndl:
                 hndl = x
                 break
 
@@ -373,7 +380,7 @@ class Config:
                     hndl = x
                     break
             if isinstance(hndl, str):
-                raise_error("BAD_LOG_HANDLER", handler=self.logging['handler'])
+                raise error("BAD_LOG_HANDLER", handler=self.logging['handler'])
 
         self._logger = logging.getLogger(self._name)
 
@@ -407,7 +414,7 @@ class Config:
         if self.logging["handler"]["class"] == "TimedRotatingFileHandler":
             x = params.get('filename')
             if x is None:
-                raise_error("NA_FILE_NAME")
+                raise error("NA_FILE_NAME")
             Path(x).parents[0].mkdir(parents=True, exist_ok=True)
             with open(x, 'a'):
                 ...
@@ -522,7 +529,7 @@ class Config:
 
     def db_connection(self, connection:str="")->str:
         if not Config.hasattr("database"):
-            raise_error("NA_DB_IN_CONFIG")
+            raise error("NA_DB_IN_CONFIG")
         db = self.database
         if isinstance(db, str) and connection=="":
             return db
@@ -530,5 +537,5 @@ class Config:
             dflt = self.defaults if self.hasattr("defaults") else {}
             db = db.get(connection, db.get(dflt.get("database", "main")))
         if not db:
-            raise_error("NA_DB", connection=connection)
+            raise error("NA_DB", connection=connection)
         return db

{ab_engine-0.2.0 → ab_engine-0.2.1}/ab_engine/env/db_context.py

@@ -88,11 +88,11 @@ class DB_ENV(UserDict):
         return ret.value if isinstance(ret, Property) else ret
 
     def __setitem__(self, key, value):
-        x = self.get(key)
+        x = self.data.get(key)
         if isinstance(x, Property):
             x.value = value
         else:
-            super.__setitem__(key, value)
+            super().__setitem__(key, value)
 
     def has_item(self, key):
         # возвращает True если в данном DB_ENV хранится переменная с именем key
@@ -140,7 +140,7 @@ class DB_ENV(UserDict):
             query = await self._context.connection.parse_func(query, **kwargs)
         elif cmd==r"\d":
             return await self._context.connection.table_struct(query.strip())
-        elif cmd=="\json":
+        elif cmd==r"\json":
             query, params = query.split("(", 1)
             if params.lower() in ("json)", "jsonb)"):
                 args = (kwargs,) + args

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

@@ -35,6 +35,9 @@
 - code: BAD_FN_PARAMS
   class: RuntimeError
   msg: Ошибка параметров регистрации функции {name} {defs}
+- code: BAD_KEY
+  class: RuntimeError
+  msg: ключ не может содержать знаков операций, открывающих круглых скобок и пробелов {key}
 ### Ошибки JsonRPC
 - code: -32700
   msg: Ошибка разбора сообщения # "Parse error"
@@ -56,6 +59,9 @@
 - code: BAD_CONFIG_PATH
   class: AttributeError
   msg: Не задан путь к файлу конфигурации
+- code: BAD_CONFIG_TYPE
+  class: AttributeError
+  msg: Неизвестный формат данных конфигурации
 - code: INFO_LOG_START
   msg: Настройки логирования инициализированы
 - code: ATTR_NOT_FOUND

{ab_engine-0.2.0 → ab_engine-0.2.1}/ab_engine/rpc/json_rpc.py

@@ -29,19 +29,17 @@ class JSON_RPC:
         if header:
             if "id" in header:
                 code["id"] = header["id"]
-        else:
-            header = {}
-        code["jsonrpc"] = header.get("jsonrpc", "2.0")
+            code["jsonrpc"] = header.get("jsonrpc", "2.0")
         return code
 
     def __init__(self, connection = None):
         self._con = connection
 
-    async def _rpc(self, env, method, header, params):
+    async def _rpc(self, env, method, params):
         # можно перезагрузить в наследниках, чтобы например, вызывать команды мз другого списка
         f = Fnc.search(method)
         if f is None:
-            return self.rpc_error(-32601, header=header)
+            return self.rpc_error(-32601)
         if isinstance(params, list):
             params = {"LIST_OF_PARAMS": params}
         elif not isinstance(params, dict):
@@ -59,12 +57,14 @@ class JSON_RPC:
         f = message['method']
         self.log(f"CALL:{f}")
         try:
-            res = await self._rpc(env, f, message, params)
-            if isinstance(res, tuple):
-                res = list(res)
+            res = await self._rpc(env, f, params)
+            if isinstance(res, dict) and len(res) == 1 and "error" in res:
+                ...
+            elif isinstance(res, tuple):
+                res = {"result": list(res)}
             elif not isinstance(res, (dict, list, str)):
-                res = str(res)
-            elif not (isinstance(res, dict) and len(res) == 1 and "error" in res):
+                res = {"result": str(res)}
+            else:
                 res = {"result": res}
             res["jsonrpc"]=message.get("jsonrpc", "2.0")
             if res["jsonrpc"]=="1.0":

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

@@ -250,7 +250,7 @@ def register_list(defs:list | dict, self=None)->None:
         else:
             match fnc.get("type", "db"):
                 case "db":
-                    SqlFnc(x, f"\JSON {fnc['function']}(JSONB)", help=fnc.get('help'))
+                    SqlFnc(x, f"{r'\JSON'} {fnc['function']}(JSONB)", help=fnc.get('help'))
                 case "self":
                     fn = getattr(self, fnc['function'])
                     PythonFnc(x, fn, help = fnc.get('help') )

ab_engine-0.2.0/readme.md → ab_engine-0.2.1/ab_engine.egg-info/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: ab_engine
+Version: 0.2.1
+Summary: Library of standard modules
+Author-email: Andrew Bulatov <BulatovAndrew@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/a-bulatov/ab_engine
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: json5>=0.12.0
+Requires-Dist: psycopg>=3.2.9
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: toml>=0.10.2
+
 Библиотека стандартных модулей
 ==========================================================
 
@@ -363,12 +377,39 @@ logging:
 
 Можно описывать драйвера к другим БД. Для того чтобы использовать собственный драйвер, можно добавить класс драйвера
 в словарь DRIVER_CLASSES, который находится в модуле ab_engine/db/option, либо положить драйвер в каталог драйверов.
+
 Пример драйвера в DRIVER_CLASSES:
+```python
+from ab_engine.db import sql, ONE, DB
+from ab_engine.db.option import DRIVER_CLASSES
+from ab_engine.db.driver_postgresql import Driver
+import asyncio
+
+class MyPgDriver(Driver):
+
+    async def begin(self):
+        await super().begin()
+        print("BEGIN TRANSACTION", flush=True)
+
+    async def rollback(self):
+        await super().rollback()
+        print("END TRANSACTION", flush=True)
+
+DRIVER_CLASSES["my_pg"] = MyPgDriver
 
-необходимости использовать собственный драйвер, можно в строке соединения в 
+async def main():
+    x = await sql("select version();", ONE, DB("my_pg://postgres:postgres@localhost:5432/postgres"))
+    print(x)
+    await DB.garbage_collect()
+
+if __name__ == '__main__':
+    asyncio.run(main())
+```
+
+При необходимости задать путь поиска с собственным драйвером, можно в строке соединения, в 
 фигурных скобках задать параметр **driver_path**, определяющий путь для поиска драйвера.
 
-Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр db_driver_path в defaults конфигурации.
+Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр **db_driver_path** в секции конфигурации **defaults**.
 
 Если приложению требуется только одна строка соединения, то ее можно задать в переменной database, например:
 
@@ -376,7 +417,7 @@ logging:
 database: postgresql://localhost:5432/postgres?user=postgres&password=postgres
 ```
 
-Также можно задать несколько соединений, если использовать database как секцию:
+Чтобы задать несколько соединений, нужно использовать database как секцию:
 
 ```toml
 [database]
@@ -387,7 +428,7 @@ mydb = "postgresql://localhost:5432/mydb?user=postgres&password=postgres"
 database = "test"
 ```
 
-При этом, в секции defaults можно задать имя соединения БД, которое будет использоваться по умолчанию (см пример выше)
+При этом, в секции **defaults** можно задать имя соединения БД, которое будет использоваться по умолчанию. Для этого следует задать значение **database** в секции **defaults**.
 
 Строка соединения с БД имеет следующую структуру:
 <имя_драйвера>**://**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
@@ -404,10 +445,15 @@ database = "test"
     который ограничит максимальное количество таких соединений. Т.е. по достижении данного числа соединений система
     не станет выполнять очередную команду до тех пор, пока не освободится одно из текущих соединений с БД.
 
-Для некоторых драйверо, например, для встроенного драйвера posstgresql строка сооединения с БД 
+Для некоторых драйверов, например, для встроенного драйвера posstgresql строка сооединения с БД 
 может иметь альтернативную структуру:
 
-<имя_драйвера>**://**<имя пользователя>**:**<пароль>**"**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
+<имя_драйвера>**://**<имя пользователя>**:**<пароль>**@**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
+
+Если нужно установить **peer** соединение c БД postgresql, то в строке соединения достаточно передать имя БД и доп. параметры (если нужно). Например:
+```python
+x = await sql("select version()", ONE, DB("postgresql://postgres?application_name=test"))
+```
 
 Драйвер БД должен иметь имя driver_<имя в строке соединения>.py и предоставлять следующий контракт:
 
@@ -1206,7 +1252,7 @@ if __name__ == '__main__':
 
 Методы RPC регистрируются функцией register_rpc_list либо c помощью декоратора register_rpc, который также можно использовать как функцию.
 
-Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход парамектры defs и self.
+Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход параметры defs и self.
 * **defs** - содержит список или словарь с описаниями
 * **self** - необязательный параметр, в котором передается модуль или объект из которого будут регистрироваться функции. если в self ничего не передано, то будут регистрироваться функции из модуля, в котором вызвана register_rpc_list.
 

{ab_engine-0.2.0 → ab_engine-0.2.1}/ab_engine.egg-info/requires.txt

@@ -1,4 +1,4 @@
 json5>=0.12.0
 psycopg>=3.2.9
-pyaml>=25.7.0
+pyyaml>=6.0.3
 toml>=0.10.2

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

@@ -1,6 +1,6 @@
 [project]
 name = "ab_engine"
-version = "0.2.0"
+version = "0.2.1"
 description = "Library of standard modules"
 authors = [{name = "Andrew Bulatov", email = "BulatovAndrew@gmail.com"}]
 license = "MIT"
@@ -9,7 +9,7 @@ requires-python = ">=3.10"
 dependencies = [
     "json5>=0.12.0",
     "psycopg>=3.2.9",
-    "pyaml>=25.7.0",
+    "pyyaml>=6.0.3",
     "toml>=0.10.2",
 ]
 [project.urls]

ab_engine-0.2.0/PKG-INFO → ab_engine-0.2.1/readme.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: ab_engine
-Version: 0.2.0
-Summary: Library of standard modules
-Author-email: Andrew Bulatov <BulatovAndrew@gmail.com>
-License-Expression: MIT
-Project-URL: Repository, https://github.com/a-bulatov/ab_engine
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: json5>=0.12.0
-Requires-Dist: psycopg>=3.2.9
-Requires-Dist: pyaml>=25.7.0
-Requires-Dist: toml>=0.10.2
-
 Библиотека стандартных модулей
 ==========================================================
 
@@ -377,12 +363,39 @@ logging:
 
 Можно описывать драйвера к другим БД. Для того чтобы использовать собственный драйвер, можно добавить класс драйвера
 в словарь DRIVER_CLASSES, который находится в модуле ab_engine/db/option, либо положить драйвер в каталог драйверов.
+
 Пример драйвера в DRIVER_CLASSES:
+```python
+from ab_engine.db import sql, ONE, DB
+from ab_engine.db.option import DRIVER_CLASSES
+from ab_engine.db.driver_postgresql import Driver
+import asyncio
+
+class MyPgDriver(Driver):
+
+    async def begin(self):
+        await super().begin()
+        print("BEGIN TRANSACTION", flush=True)
+
+    async def rollback(self):
+        await super().rollback()
+        print("END TRANSACTION", flush=True)
+
+DRIVER_CLASSES["my_pg"] = MyPgDriver
 
-необходимости использовать собственный драйвер, можно в строке соединения в 
+async def main():
+    x = await sql("select version();", ONE, DB("my_pg://postgres:postgres@localhost:5432/postgres"))
+    print(x)
+    await DB.garbage_collect()
+
+if __name__ == '__main__':
+    asyncio.run(main())
+```
+
+При необходимости задать путь поиска с собственным драйвером, можно в строке соединения, в 
 фигурных скобках задать параметр **driver_path**, определяющий путь для поиска драйвера.
 
-Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр db_driver_path в defaults конфигурации.
+Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр **db_driver_path** в секции конфигурации **defaults**.
 
 Если приложению требуется только одна строка соединения, то ее можно задать в переменной database, например:
 
@@ -390,7 +403,7 @@ logging:
 database: postgresql://localhost:5432/postgres?user=postgres&password=postgres
 ```
 
-Также можно задать несколько соединений, если использовать database как секцию:
+Чтобы задать несколько соединений, нужно использовать database как секцию:
 
 ```toml
 [database]
@@ -401,7 +414,7 @@ mydb = "postgresql://localhost:5432/mydb?user=postgres&password=postgres"
 database = "test"
 ```
 
-При этом, в секции defaults можно задать имя соединения БД, которое будет использоваться по умолчанию (см пример выше)
+При этом, в секции **defaults** можно задать имя соединения БД, которое будет использоваться по умолчанию. Для этого следует задать значение **database** в секции **defaults**.
 
 Строка соединения с БД имеет следующую структуру:
 <имя_драйвера>**://**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
@@ -418,10 +431,15 @@ database = "test"
     который ограничит максимальное количество таких соединений. Т.е. по достижении данного числа соединений система
     не станет выполнять очередную команду до тех пор, пока не освободится одно из текущих соединений с БД.
 
-Для некоторых драйверо, например, для встроенного драйвера posstgresql строка сооединения с БД 
+Для некоторых драйверов, например, для встроенного драйвера posstgresql строка сооединения с БД 
 может иметь альтернативную структуру:
 
-<имя_драйвера>**://**<имя пользователя>**:**<пароль>**"**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
+<имя_драйвера>**://**<имя пользователя>**:**<пароль>**@**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
+
+Если нужно установить **peer** соединение c БД postgresql, то в строке соединения достаточно передать имя БД и доп. параметры (если нужно). Например:
+```python
+x = await sql("select version()", ONE, DB("postgresql://postgres?application_name=test"))
+```
 
 Драйвер БД должен иметь имя driver_<имя в строке соединения>.py и предоставлять следующий контракт:
 
@@ -1220,7 +1238,7 @@ if __name__ == '__main__':
 
 Методы RPC регистрируются функцией register_rpc_list либо c помощью декоратора register_rpc, который также можно использовать как функцию.
 
-Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход парамектры defs и self.
+Регистрация списка функций осуществляется с помощью register_rpc_list, которая принимает на вход параметры defs и self.
 * **defs** - содержит список или словарь с описаниями
 * **self** - необязательный параметр, в котором передается модуль или объект из которого будут регистрироваться функции. если в self ничего не передано, то будут регистрироваться функции из модуля, в котором вызвана register_rpc_list.