ab_engine 0.1.3__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab_engine
-Version: 0.1.3
+Version: 0.2.0
 Summary: Library of standard modules
 Author-email: Andrew Bulatov <BulatovAndrew@gmail.com>
 License-Expression: MIT
@@ -45,7 +45,7 @@ Requires-Dist: toml>=0.10.2
 **env_map** - задает соответствие ключей словаря переменным окружения.  если такое соответствие заддано, то после
 загрузки параметров из файлов, система заменяет значения в словаре значениями из переменныых окружения.
 
-Если в окружении нет таких переменных, то в качестве значения остается то значение, которое было загружено из файла.
+Если в окружении нет таких переменных, то в качестве значения остается, то значение, которое было загружено из файла.
 Структура для задания соответствия переменным окружения является словарем вида:
 
 ```json
@@ -373,16 +373,16 @@ logging:
 ## Доступ к БД
 
 Библиотека поддерживает хранение настроек соединений и выполнение команд SQL на этих соединениях с БД.
-Из коробки реализованы драйвер Postgresql, Sqlite, Mysql (но надо установить зависимость mysql-connector-python)
+Из коробки реализованы драйвер Postgresql, Sqlite и Valkey (Redis). Также реализован драйвер Mysql но для его работы дополнительно надо установить зависимость mysql-connector-python.
 
 Можно описывать драйвера к другим БД. Для того чтобы использовать собственный драйвер, можно добавить класс драйвера
 в словарь DRIVER_CLASSES, который находится в модуле ab_engine/db/option, либо положить драйвер в каталог драйверов.
 Пример драйвера в DRIVER_CLASSES:
 
-необходимости использовать собственный драйвер, можно в встроке соединения в 
-фигурных скобках задать параметр **driver_path**, определяющий путь для поиска драйвра.
+необходимости использовать собственный драйвер, можно в строке соединения в 
+фигурных скобках задать параметр **driver_path**, определяющий путь для поиска драйвера.
 
-Если нужно задать свой путь поиска для всех драйверов БД, можэно задать параметр db_driver_path в defaults конфигурации.
+Если нужно задать свой путь поиска для всех драйверов БД, можно задать параметр db_driver_path в defaults конфигурации.
 
 Если приложению требуется только одна строка соединения, то ее можно задать в переменной database, например:
 
@@ -411,12 +411,17 @@ database = "test"
                           помимо параметров, определяемых драйвером, можно передать параметр driver_path, который 
                           определяет путь поиска драйвера
 
-* **дополнительные параметры**  - параметры, которые будут переданы в сессию соединения с БД (в фигуреых скобках). 
+* **дополнительные параметры**  - параметры, которые будут переданы в сессию соединения с БД (в фигурных скобках). 
     передаются как **"**ключ**"="**значение**"**
     в качестве разделителя параметров используется запятая. 
     Для любого сочетания драйвер+строка соединения-доп.параметры, можно задать дополнительный параметр LIMIT, 
     который ограничит максимальное количество таких соединений. Т.е. по достижении данного числа соединений система
-    не станет выполнять очередную команду до тех пор, пока не освободится одно из текущихз соединений с БД.
+    не станет выполнять очередную команду до тех пор, пока не освободится одно из текущих соединений с БД.
+
+Для некоторых драйверо, например, для встроенного драйвера posstgresql строка сооединения с БД 
+может иметь альтернативную структуру:
+
+<имя_драйвера>**://**<имя пользователя>**:**<пароль>**"**<адрес сервера>**:**<номер порта>**/**<имя БД>**?**<параметры соединения>**{**дополнительные параметры**}**
 
 Драйвер БД должен иметь имя driver_<имя в строке соединения>.py и предоставлять следующий контракт:
 
@@ -424,16 +429,20 @@ database = "test"
 class Driver:
 
     @abstractmethod
-    def __init__(self, connection_string, on_open_close=None):
+    def __init__(self, connection_string, on_open_close=None, notify=None, out_params:Optional[dict]=None):
         """
         констркуктор драйвера.
         должен разобрать строку соединения (описана выше) и инициализировать экземпляр драйвера.
         дополнительные параметры строки соединения (те что в фигурных скобках) не передаются в строку 
         соединения.
         on_open_close функция, передаваемая драйверу, описываемая как 
-        async def on_open_close(self, close=False)->dict:
-        данная функция возвращает драйверу дополнительные параметры, которые могут быть использованы 
-        при создании и закрытии соединения (если драйвер это поддерживает) 
+            async def on_open_close(self, close=False)->dict:
+            данная функция возвращает драйверу дополнительные параметры, которые могут быть использованы 
+            при создании и закрытии соединения (если драйвер это поддерживает) 
+        notify список, в который будут записаны уведомления о событиях, либо метод, который будет 
+            вызван для каждого события. метод может быть как синхронным, так и асинхронным, на его входе строка.
+        out_params словарь выходных параметров. используется в конструкторе драйверов для получения
+            разобранного connection_string
         """
         ...
 
@@ -469,7 +478,7 @@ class Driver:
         если one_row=False и выборка пуста
         Если one_row=True, то вернет только первую строку результата, либо Null, 
         если соответствующая запись не найдена.
-        В случае, если query яляется запросом, не возвращающим выборку, вернет 
+        В случае, если query является запросом, не возвращающим выборку, вернет 
         целое число - количество записей, на которые повлиял запрос.
         """
         #if self._conn is None:
@@ -559,7 +568,7 @@ class Driver:
 Функция **parse_func** позволяет унифицировать вызов функций. Подставляет необходимый для вызова префикс и вызывает
 parse_query для подстановки параметров.
 
-Функция **parse_query** обеспечивает безопасную подстановку значений параметров в запрос. Для того, чтобы указать
+Функция **parse_query** обеспечивает безопасную подстановку значений параметров в запрос. Для того чтобы указать
 в тексте запроса параметр, следует указать $<номер параметра> и тогда запрос будет взят из args с номером на единицу меньшим.
 Либо указать $<имя параметра> в этом случае значение будет взято из kwargs с тем же именем. Номер всегда состоит только из цифр.
 Имя начинается с буквы и заканчивается перед пробельным символом или перед скобкой, или двоеточием, или запятой. 
@@ -630,6 +639,11 @@ if __name__ == '__main__':
 В этом примере стало необязательно указывать опцию DB, тк если она не указана, то система берет ту строку соединения,
 которая указана в файле конфигурации.
 
+Для того чтобы установить PEER соединение с postgresql от имени текущего пользователя, достаточно указать имя драйвера
+и имя базы данных:
+```yaml config.yaml
+database: postgresql://postgres
+```
 Для выполнения запроса, в обоих примерах, мы использовали функцию sql из ab_engine.db, которая определяется как:
 ```python
 async def sql(query:str, *args, **kwargs):
@@ -641,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). Установлена по умолчанию
@@ -649,11 +664,12 @@ async def sql(query:str, *args, **kwargs):
 * ROW    - Указывает, что нужно вернуть только первую строку из выборки
 * ONE    - Указывает, что нужно вернуть только значение первого поля из первой строки выборки
 * JSON   - Указывает, что значение первого поля в первой строке следует привести к dict или list
-* ROLLBACK - казывает, что после выполнения запроса соединение должно быть закрыто с откатом транзакции
+* ROLLBACK - указывает, что после выполнения запроса соединение должно быть закрыто с откатом транзакции
 * COMMIT - Указывает, что после выполнения запроса соединение должно быть закрыто с подтверждением транзакции
 * PAGE   - Позволяет задать максимальный размер страницы и её смещение от начала выборки (limit, offset)
 * ITERATOR - Если опция задана, то результатом функции sql будет итератор для работы с большими таблицами в async for
 * ALL    - Специальная опция, добавлена для принудительного отключения фильтров в функциях, которые это понимают (например у экземпляра Table)
+* RAW    - Отключает предобработку запроса с подстановкой параметров
 * CALLBACK - Из функции sql отдает в callback_function запрос с подставленными параметрами. Что позволяет доработать запрос или вывести в лог.
         Eсли callback_function возвращает строку, то именно эта строка станет запросом. Функция sql вызывает только первый callback из args
 
@@ -706,11 +722,13 @@ DB_ENV реализует следующий контракт:
 ```python
 class DB_ENV:
 
-    def __init__(self, connection: str="", db_params:Optional[set]=None, **kwargs):
+    def __init__(self, connection: str="", db_params:Optional[set]=None, notify=None, **kwargs):
         """
         Окружение для работы с БД
-        :param connection: строка соеддинения или экземпляр DB_ENV, на основе которого нужно создать данный
-        :param db_params: список переменных, которые должны передаваться в в окружение соединения с БД
+        :param connection: строка соединения или экземпляр DB_ENV, на основе которого нужно создать данный
+        :param db_params: список переменных, которые должны передаваться в окружение соединения с БД
+        :param notify: список или функция, в которую будут переданы извещения о событиях. 
+                       функция может быть синхронной или асинхронной и должна принимать на вход один параметр.
         :param kwargs: значения переменных
         """
         
@@ -819,7 +837,7 @@ if __name__ == '__main__':
 контекст завершит транзакцию и откатит её, т.е. результат выполнения insert не будет сохранен.
 В данном случае DB_ENV создан без параметров, но он может принять на вход:
 * connection - строку соединения с БД. это позволяет задать соединение отличное от заданного файла конфигурации. но, 
-  тем не менее, окружение не может работать без конфигурации потому что троебует и других настроек, например настроек ведения лога.
+  тем не менее, окружение не может работать без конфигурации потому что требует и других настроек, например настроек ведения лога.
 * params - словарь с дополнительными параметрами соединения. например, тут можно передать id текущего пользователя или 
  еще какие-то параметры сессии.
 
@@ -853,10 +871,10 @@ if __name__ == '__main__':
 |----------------------------|-------------------------------|----------------|
 | * имя_таблицы              | select * from имя_таблицы     | 
 | \\JSON имя_функции(параметры)| select имя_функции(параметры) | вместо select может быть другая команда, в зависимости от дроайвера СУБД|
-| \\JSON имя_функции(JSON)     | select имя_функции($1::json)  | selecn и преобразование ::jsonb завист от СУБД, **kwargs функции sql будут переданы как параметр типа json|
+| \\JSON имя_функции(JSON)     | select имя_функции($1::json)  | selecn и преобразование ::jsonb зависит от СУБД, **kwargs функции sql будут переданы как параметр типа json|
 | \\JSON имя_функции(JSONB)    | select имя_функции($1::json)  | как и выше, но параметр приводится к jsonb (если это поддерживает СУБД, иначе к json)|
 | \\d имя_таблицы              |                               | возвращает json, содержащий структуру таблицы |
-| \\call имя_функции           |                               | вызывает функцию, полставляя *args, **kwargs как параметры |
+| \\call имя_функции           |                               | вызывает функцию, подставляя *args, **kwargs как параметры |
 
 При вызове запросов из DB_ENV можно использовать параметры, например:
 ```python
@@ -876,6 +894,62 @@ async def test():
     print(x) # также выведет 10
 ```
 
+#### Особенности работы с Valkey
+
+В случае подключения драйвера Valkey, работа с библиотекой отличается от работы с sql базами данных:
+1) В качестве входного языка для функций sql используется язык redis-cli с которым можно ознакомиться, например, в [The Little Book](https://github.com/akandratovich/the-little-redis-book/blob/master/ru/redis.md)
+2) Поскольку это не язык SQL, то и описанные выше расширения синтаксиса неприменимы к Valkey
+3) Опции позволяющие менять обработку sql, например, ONE не имеют смысла для Valkey
+
+Проиллюстрируем работу с Valkey на примере. 
+Для этого создадим файл test.toml следующего содержания.
+```toml
+[database]
+valkey = "valkey://localhost:6379/0"
+```
+вместо localhost:6379 в файле должны быть заданы адрес хоста и порт Valkey.
+
+Далее напишем следующий код на python:
+```python
+import asyncio
+from ab_engine.db import ONE
+from ab_engine import Config
+from ab_engine.env import DB_ENV
+
+async def main():
+    notify = [] # массив для получения уведомлений
+    env = DB_ENV("valkey", notify=notify)
+    # запишем 123 по ключу x и проверим значение ключа
+    await env.sql("set x 123")
+    x = await env.sql("get x")
+    print(x)
+    # теперь запишем 321, но с использованием параметров
+    await env.sql("set x $1", 321)
+    x = await env.sql("get x")
+    print(x)
+    # запустим цикл для получения уведомлений от Valkey
+    # в данном случае будем получать уведомления в ранее объявленный список notify, но можно было бы передать в
+    # параметр notify конструктора DB_ENV ссылку на функцию с одним обязательным аргументом, тогда уведомления
+    # будут передаваться в эту функцию
+
+    # подписываемся на уведомления публикаций темы test
+    await env.sql("subscribe test")
+
+    # теперь, пока открыто наше соедингение мы будем получать уведомления, если кто-то выполнит в Valkey команду:
+    # publish test "какой-то текст"
+    while True:
+        if notify:
+            print("Уведомления:")
+            while len(notify) > 0:
+                print("  ", notify.pop(0))
+        await asyncio.sleep(0.2)
+
+if __name__ == '__main__':
+    Config("test.toml")
+    asyncio.run(main())
+```
+
+
 ## Работа с курсорами таблиц БД
 
 Курсор таблицы может быть получен из DB_ENV посредством функции table. 
@@ -1144,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
@@ -1299,7 +1431,7 @@ if __name__ == '__main__':
 ## Поддержка плагинов
 
 Плагины, как и sql-запросы и функции python регистрируются с помощью функции register_rpc.
-Создадим plugin.py с  примером плагина:
+Создадим plugin.py с примером плагина:
 ```python
 def test(**kwargs):
     if kwargs:
@@ -1325,7 +1457,7 @@ async def main():
 if __name__ == '__main__':
     asyncio.run(main())
 ```
-Из этого примера можно увидеть как регистрируются функци плагинов.
+Из этого примера можно увидеть как регистрируются функции плагинов.
 Также, из примера следует, что функция call_rpc умеет вызывать как асинхронные, так и обычные функции.
 
 Функции плагинов могут получать экземпляр текущего окружения (DB_ENV).
@@ -1337,13 +1469,13 @@ async def with_env(env, **kwargs):
     x.update(kwargs)
     return x
 ```
-также нам понадобится файл test.toml следующего содержания:
+Также нам понадобится файл test.toml следующего содержания:
 ```toml
 [defaults]
 plugin_path = "./"
 ```
 
-и основной код примера:
+И основной код примера:
 ```python
 from ab_engine import register_rpc, call_rpc, Config
 from ab_engine.env import DB_ENV
@@ -1351,7 +1483,7 @@ import asyncio
 
 async def main():
     Config("test.toml")
-    register_rpc("plugin", "_plugin.py:with_env")
+    register_rpc("plugin", "plugin.py:with_env") # не указан путь
     env = DB_ENV(c=3, d=4)
     x = await call_rpc("plugin", env, a=1, b=2)
     print(x)
@@ -1359,5 +1491,10 @@ async def main():
 if __name__ == '__main__':
     asyncio.run(main())
 ```
-в данном примере в функцию плагина будет передан экземпляр окружения, из которого она фвозьмет параметры и объединит 
+В данном примере в функцию плагина будет передан экземпляр окружения, из которого она возьмет параметры и объединит 
 их с параметрами, переданными в функцию.
+
+В этом примере следует отметить, что путь к коду плагина не указан в параметре функции register_rpc.
+Путь поиска плагинов в этом примере задан в файле test.toml в параметре plugin_path.
+В параметре plugin_path можно указать несколько путей поиска, разделенных ; (точкой с запятой), поиск 
+файла в этом случае будет идти в том порядке, в котором перечислены пути.  

{ab_engine-0.1.3 → 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.3 → ab_engine-0.2.0}/ab_engine/db/__init__.py

@@ -1,3 +1,3 @@
-from .option import DB, TUPLE, OBJECT, ONE, ROW, ROLLBACK, COMMIT, JSON, TIMEOUT, PAGE, CALLBACK, ITERATOR
+from .option import DB, TUPLE, OBJECT, ONE, ROW, ROLLBACK, COMMIT, JSON, TIMEOUT, PAGE, CALLBACK, ITERATOR, RAW
 from .processor import sql, set_connection
 from .table import Table

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

@@ -3,6 +3,9 @@ from json import dumps
 from datetime import datetime
 from abc import ABC, abstractmethod
 from collections import namedtuple
+from typing import Optional
+from urllib.parse import unquote
+from inspect import iscoroutinefunction
 
 _is_option = None
 
@@ -31,16 +34,61 @@ def reencode(s):
 
 class Driver(ABC):
 
-    LIKE = "LIKE"
+    LIKE = "LIKE" # что использовать как like, например для postgresql это ILIKE
 
-    def __init__(self, connection_string, on_open_close=None):
+    def __init__(self, connection_string, on_open_close=None, notify=None, out_params:Optional[dict]=None):
         self._conn = None
         if isinstance(connection_string, Driver):
             self._conn_str = connection_string.connection_string
             self._on_open_close = on_open_close or connection_string._on_open_close
             return
+        self._notify = notify
         self._on_open_close = on_open_close
+        connection_string = connection_string.strip()
+        connection_string, options = connection_string.split("{",1) if "{" in connection_string and connection_string.endswith("}") else connection_string, "}"
+        options = options[:-1]
         self._conn_str = connection_string
+        if out_params is None:
+            return
+        out_params["options"]=options
+        connection_string, options = f"{connection_string}?".split("?",1)
+        options = options[:-1]
+        if options!="":
+            options=options.split("&")
+            for n, x in enumerate(options):
+                x = x.split("=",1)
+                if len(x)==1:
+                    x.append("")
+                options[n] = (unquote(x[0]),unquote(x[1]),)
+        out_params["params"] = {x[0]:x[1] for x in options}
+        if "@" in connection_string:
+            options, connection_string = connection_string.split("@", 1)
+            if ":" in options:
+                options = options.split(":", 1)
+                out_params["user"] = unquote(options[0])
+                out_params["password"] = unquote(options[1])
+            else:
+                out_params["user"] = unquote(options)
+        if "/"in connection_string:
+            connection_string, options = connection_string.split("/", 1)
+            out_params["database"] = unquote(options)
+            if ":" in connection_string:
+                connection_string, options = connection_string.rsplit(":", 1)
+                try:
+                    out_params["port"] = int(options)
+                except Exception as e:
+                    raise ValueError("The port number must be an integer")
+            out_params["host"] = unquote(connection_string)
+        else:
+            out_params["database"] = unquote(connection_string)
+
+    async def _notify_callback(self, notify):
+        if isinstance(self._notify, list):
+            self._notify.append(notify)
+        elif iscoroutinefunction(self._notify):
+            await self._notify(notify)
+        elif callable(self._notify):
+            self._notify(notify)
 
     @property
     def connection_string(self):
@@ -103,10 +151,10 @@ class Driver(ABC):
                 return reencode(var)
             else:
                 var = ','.join(['NULL' if x is None else str(x) for x in var])
-                return reencode(var)
+                return reencode(f"{{{var}}}")
         elif isinstance(var, set):
             var = ','.join('NULL' if x is None else str(x) for x in var)
-            return reencode(var)
+            return reencode(f"{{{var}}}")
         elif isinstance(var, dict):
             var = dumps(var, ensure_ascii=False).replace("'", "''")
             return reencode(var)
@@ -120,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
@@ -143,10 +192,11 @@ class Driver(ABC):
                     n = callback[n]
                 else:
                     raise AttributeError(f"Attribute with name {n} is not exists")
-            qs += f"{self.var_to_sql(n, x)}{x[p:]}"
+            x = x[p:]
+            qs += f"{self.var_to_sql(n, x)}{x}"
             
         if qs:
-            query = qs
+            query = qs.replace("🗿", "$$")
 
         return query
 

{ab_engine-0.1.3 → ab_engine-0.2.0}/ab_engine/db/driver_mysql.py

@@ -37,7 +37,7 @@ _FACTORY_ = {
 
 class Driver(BaseDriver):
 
-    def __init__(self, connection_string, on_open_close=None):
+    def __init__(self, connection_string, on_open_close=None, notify=None):
         """
         localhost:3306/mysql?user=root&password=root
         """

{ab_engine-0.1.3 → ab_engine-0.2.0}/ab_engine/db/driver_postgresql.py

@@ -26,28 +26,25 @@ class Driver(BaseDriver):
 
     LIKE = "ILIKE"
 
-    def __init__(self, connection_string, on_open_close=None):
+    def __init__(self, connection_string, on_open_close=None, notify=None):
         """
         localhost:5432/postgres?user=postgres&password=postgres
         """
-        super().__init__(connection_string, on_open_close)
-        host, options = self.connection_string.split("/", 1)
-        if ":" in host:
-            host, port = host.split(":", 1)
-            port = int(port.strip())
-        else:
-            port = None
-        options = options.split("?", 1)
-        dbname = options[0]
-        if len(options) == 2:
-            options = options[1].replace("&", " ")
-        else:
-            options = ""
-        self._conn_str = f"host={host} dbname={dbname}"
-        if port is not None:
-            self._conn_str += f" port={port}"
-        if options != "":
-            self._conn_str += " " + options
+        drv_params = {}
+        super().__init__(connection_string, on_open_close, out_params=drv_params, notify=notify)
+        if "user" in drv_params:
+            drv_params["params"]["user"] = drv_params["user"]
+        if "password" in drv_params:
+            drv_params["params"]["password"] = drv_params["password"]
+        con = ""
+        if "host" in drv_params:
+            con += f"host={drv_params['host']} "
+        con += f"dbname={drv_params['database']} "
+        if "port" in drv_params:
+            con += f"port={drv_params['port']} "
+        for x in drv_params["params"]:
+            con += f"{x}={drv_params['params'][x]} "
+        self._conn_str = con.strip()
 
     @property
     def in_transaction(self):
@@ -61,6 +58,12 @@ class Driver(BaseDriver):
                 await self._conn.execute(f"set session timezone '{params[x]}'")
             else:
                 await self._conn.execute(f"SET {x} = '{params[x]}'")
+        if self._notify:
+            self._conn.add_notify_handler(self._notify_callback)
+
+    async def _notify_callback(self, notify):
+        notify = notify if isinstance(notify, str) else f"[{notify.pid}: {notify.channel}] {notify.payload}"
+        await super()._notify_callback(notify)
 
     async def sql(self, query, one_row=False, row_factory=RowFactory.DICT):
         if self._conn is None:
@@ -69,7 +72,23 @@ class Driver(BaseDriver):
 
             acur.row_factory = _FACTORY_[row_factory.value]
 
-            await acur.execute(query)
+            if self._notify is not None:
+                notices = []
+
+                def add_notice(notify):
+                    nonlocal notices
+                    notices.append(f"[{notify.severity}] {notify.message_primary}")
+
+                try:
+                    self._conn.add_notice_handler(add_notice)
+                    await acur.execute(query)
+                finally:
+                    self._conn.remove_notice_handler(add_notice)
+                    for x in notices:
+                        await self._notify_callback(x)
+            else:
+                await acur.execute(query)
+
             descr = acur.description
             if not descr:
                 return acur.rowcount

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

@@ -46,11 +46,11 @@ _FACTORY_ = {
 
 class Driver(BaseDriver):
 
-    def __init__(self, connection_string, on_open_close=None):
+    def __init__(self, connection_string, on_open_close=None, notify=None):
         """
         test_db.sqlite
         """
-        super().__init__(connection_string, on_open_close)
+        super().__init__(connection_string, on_open_close, notify)
 
     async def begin(self):
         await self._before_open()