ab_engine 0.1.9__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab_engine
-Version: 0.1.9
+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 и предоставлять следующий контракт:
 
@@ -655,6 +687,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 +1250,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.1}/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.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}"
@@ -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.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.1.9 → ab_engine-0.2.1}/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.1}/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)
 
@@ -107,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:
@@ -216,6 +239,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 +299,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 +329,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 +368,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 +404,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.1}/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,7 +61,7 @@ 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:
+    if callback is not None:
         kwargs["__PARAM_CALLBACK_GETTER"] = callback
     if parse:
         query = await db.connection.parse_query(query, *args, **kwargs)
@@ -71,7 +71,7 @@ async def sql(query:str, *args, **kwargs):
         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.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.1.9 → 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'):
                 ...
@@ -451,7 +458,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 +488,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 +519,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:
             # Больше вывести некуда - выводим на стандартный вывод
@@ -518,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
@@ -526,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.1.9 → 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