ab_engine 0.1.1__py3-none-any.whl

ab_engine/__init__.py

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

ab_engine/class_tools.py

@@ -0,0 +1,59 @@
+class ClassPropertyDescriptor(object):
+
+    def __init__(self, fget, fset=None):
+        self.fget = fget
+        self.fset = fset
+
+    def __get__(self, obj, klass=None):
+        if klass is None:
+            klass = type(obj)
+        return self.fget.__get__(obj, klass)()
+
+    def __set__(self, obj, value):
+        if not self.fset:
+            raise AttributeError("can't set attribute")
+        type_ = type(obj)
+        return self.fset.__get__(obj, type_)(value)
+
+    def setter(self, func):
+        if not isinstance(func, (classmethod, staticmethod)):
+            func = classmethod(func)
+        self.fset = func
+        return self
+
+def classproperty(func):
+    if not isinstance(func, (classmethod, staticmethod)):
+        func = classmethod(func)
+
+    return ClassPropertyDescriptor(func)
+
+def find_subclass(base, name):
+    if base.__name__ == name:
+        return base
+    for cls in base.__subclasses__():
+        cls = find_subclass(cls, name)
+        if cls:
+            return cls
+    return None
+
+
+class ReadOnlyPropDict:
+
+    def __init__(self,  **kwargs):
+        self._data = kwargs
+        for x in kwargs:
+            self._set_f(x)
+
+    def _set_f(self, x):
+        setattr(self.__class__, x, property(lambda p: self._data[x]))
+
+    def __getitem__(self, item):
+        return self._data[item]
+
+
+class PropDict(ReadOnlyPropDict):
+
+    def _set_f(self, x):
+        def set_f(p, v):
+            self._data[x] = v
+        setattr(self.__class__, x, property(lambda p: self._data[x], set_f))

ab_engine/db/__init__.py

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

ab_engine/db/driver.py

@@ -0,0 +1,339 @@
+from enum import Enum
+from json import dumps
+from datetime import datetime
+from abc import ABC, abstractmethod
+from collections import namedtuple
+
+_is_option = None
+
+def _set_is_option(f):
+    global _is_option
+    _is_option = f
+
+
+class RowFactory(Enum):
+    """
+    Варианты фабрик для возврата набора данных
+    """
+    ANY = 0
+    TUPLE = 1
+    DICT = 2
+    NAMED_TUPLE = 3
+
+
+def reencode(s):
+    if s is None:
+        return " NULL"
+    elif isinstance(s, str):
+        return f"'{s}'"
+    return s
+
+
+class Driver(ABC):
+
+    LIKE = "LIKE"
+
+    def __init__(self, connection_string, on_open_close=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._on_open_close = on_open_close
+        self._conn_str = connection_string
+
+    @property
+    def connection_string(self):
+        return self._conn_str
+
+    @property
+    def in_transaction(self)->bool:
+        """возвращает открыта ли транзакция"""
+        return self._conn is not None
+
+    async def _before_open(self)->dict:
+        if self._conn:
+            raise RuntimeError("Transaction already open")
+        if x := self._on_open_close:
+            params = await x(False)
+            if not params:
+                params = {}
+        else:
+            params = {}
+        return params
+
+    @abstractmethod
+    async def begin(self):
+        """открывает транзакцию"""
+        ...
+
+    @abstractmethod
+    async def sql(self, query, one_row=False, row_factory=RowFactory.DICT):
+        """выполняет запрос
+        query текст запроса
+        one_row если True, то выполняется fetchone иначе fetch
+        row_factory способ представления результата
+        если набор данных пустой и one_row==False - возвращает []
+        если набор данных пустой и one_row==True - возвращает None
+        если запрос не возвращает результат - возвращает число обработанных строк (целое)
+        """
+        ...
+
+    @abstractmethod
+    async def commit(self):
+        """подтверждает транзакцию и закрывает соединение"""
+        ...
+
+    async def rollback(self):
+        """откатывает транзакцию и закрывает соединение"""
+        if x:=self._on_open_close:
+            await x(True)
+        self._conn = None
+
+    @staticmethod
+    def var_to_sql(var, str_after=" "):
+        if var is None:
+            return " NULL"
+        elif isinstance(var, str):
+            var = var.replace("'", "''")
+            return reencode(var)
+        elif isinstance(var, (list, tuple)):
+            if str_after[:6].lower() == '::json' or str_after[0] != ':':
+                var = dumps(var, ensure_ascii=False).replace("'", "''")
+                return reencode(var)
+            else:
+                var = ','.join(['NULL' if x is None else str(x) for x in var])
+                return reencode(var)
+        elif isinstance(var, set):
+            var = ','.join('NULL' if x is None else str(x) for x in var)
+            return reencode(var)
+        elif isinstance(var, dict):
+            var = dumps(var, ensure_ascii=False).replace("'", "''")
+            return reencode(var)
+        elif isinstance(var, datetime):
+            return f" '{var}'"
+        else:
+            return f" {var}"
+
+    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")
+            qs += f"{self.var_to_sql(n, x)}{x[p:]}"
+            
+        if qs:
+            query = qs
+
+        return query
+
+    @staticmethod
+    def is_option(what):
+        global _is_option
+        if _is_option:
+            return _is_option(what)
+        else:
+            return None
+
+    async def parse_func(self, func_name, *args, **kwargs):
+        """
+        Возвращает запрос для вызова функции func_name
+        :param args: неименованные параметры
+        :param kwargs: именованные параметры
+        :return: запрос
+        """
+        ret = f"select {func_name}("
+        for n in range(len(args)):
+            if self.is_option(args[n]):
+                break
+            if n > 0:
+                ret += ", "
+            ret += f"${n+1}"
+        for n, x in enumerate(kwargs):
+            if n > 0:
+                ret += ", "
+            ret += f"${x}"
+        ret += ")"
+        return await self.parse_query(ret, *args, **kwargs)
+
+    async def cast(self, param_name, to_type):
+        """
+        возвращает часть запроса для приведения типа
+        :param param_name:
+        :param to_type:
+        :return:
+        """
+        return f"{param_name}::{to_type}"
+
+    @staticmethod
+    def ident_name(name:str)->str:
+        return name
+
+    TypeSpec = namedtuple("TypeSpec", ["type_name", "python_type", "autoincrement"])
+
+    @staticmethod
+    def _specify_type(defs):
+        if defs.data_type in ("smallint", "integer", "bigint", "smallserial", "serial", "bigserial", "int"):
+            pt = int
+        elif defs.data_type in ("double precision", "numeric", "real", "decimal", "money", "float"):
+            pt = float
+        else:
+            pt = str
+        return Driver.TypeSpec(type_name=defs.data_type, python_type=pt, autoincrement=False)
+
+    async def table_struct(self, table_name) -> dict:
+        """
+        возвращает структуру заданной таблицы
+        """
+        if not self.in_transaction:
+            await self.begin()
+        schema_name, table_name = f"{table_name}.".split(".", 1)
+        if table_name=="":
+            table_name = self.ident_name(schema_name)
+            schema_name = None
+        else:
+            table_name = self.ident_name(table_name[:-1])
+            schema_name = self.ident_name(schema_name)
+        fltr = f"\nwhere ku.table_name='{table_name}'"
+        if schema_name is not None:
+            fltr += f" and ku.table_schema='{schema_name}'"
+        qry =f"""select ku.column_name, ku.data_type, ku.is_nullable, ku.character_maximum_length, 
+                       ku.numeric_precision, ku.numeric_scale, ku.column_default
+                from information_schema.columns ku {fltr}
+                order by ku.ordinal_position"""
+        qry = await self.sql(qry, one_row=False, row_factory=RowFactory.NAMED_TUPLE)
+        if not qry:
+            return {}
+        fields = []
+        for x in qry:
+            t = self._specify_type(x)
+            field = {
+                "name": x.column_name,
+                "type": t.type_name,
+                "not_null": x.is_nullable is not None and f'{x.is_nullable} '[0].upper() in "FNН",
+                "python_type": t.python_type,
+            }
+            if t.autoincrement:
+                field["autoincrement"] =True
+            n = self.ident_name(field["name"])
+            if n!=field["name"]:
+                field["field"] = n
+            if x.character_maximum_length:
+                field["size"] = x.character_maximum_length
+            elif field["python_type"]!=int and x.numeric_precision:
+                n = f'{x.numeric_precision}.{x.numeric_scale}'
+                field["size"] = float(n)
+            fields.append(field)
+        qry = f"""select
+            x.constraint_name,
+            x.constraint_type,
+            x.column_name,
+            x.reference_schema,
+            x.reference_table,
+            r.column_name reference_column
+        from (
+            select ku.constraint_name, tc.constraint_type, ku.column_name,
+                   rt.table_schema reference_schema, rt.table_name reference_table,
+                   row_number() over (partition by ku.constraint_name order by ku.ordinal_position) column_position
+            from information_schema.key_column_usage ku
+            inner join information_schema.table_constraints tc on tc.constraint_name = ku.constraint_name and tc.table_name = ku.table_name  and tc.table_schema = ku.table_schema
+            left join information_schema.referential_constraints rc on rc.constraint_name = ku.constraint_name
+            left join information_schema.table_constraints rt on rc.unique_constraint_name = rt.constraint_name
+            {fltr}
+            order by ku.constraint_name, ku.ordinal_position
+            ) x
+        left join (
+            SELECT
+                    tc.table_name, tc.table_schema, i2.COLUMN_NAME,
+                    row_number() over (partition by tc.table_name, tc.table_schema order by  i2.ordinal_position) column_position
+                FROM
+                    information_schema.table_constraints tc
+                JOIN
+                    information_schema.key_column_usage i2
+                    ON tc.constraint_name = i2.constraint_name
+                WHERE
+                    tc.constraint_type = 'PRIMARY KEY'
+        ) r on x.reference_schema = r.table_schema and x.reference_table = r.table_name and x.column_position=r.column_position
+        order by x.constraint_name, x.column_position
+        """
+        qry = await self.sql(qry, one_row=False, row_factory=RowFactory.NAMED_TUPLE)
+        constraints = []
+        item = {"name": None}
+        for x in qry:
+            if x.constraint_name!=item["name"]:
+                if item["name"] is not None:
+                    constraints.append(item)
+                t = x.constraint_type[0].upper()
+                if t == "P":
+                    item = {
+                        "name": x.constraint_name,
+                        "fields": [],
+                        "type": "primary key"
+                    }
+                elif t == "U":
+                    item = {
+                        "name": x.constraint_name,
+                        "fields": [],
+                        "type": "unique"
+                    }
+                elif t == "F":
+                    item = {
+                        "name": x.constraint_name,
+                        "fields": {},
+                        "table": f"{self.ident_name(x.reference_schema)}.{self.ident_name(x.reference_table)}",
+                        "type": "foreign key"
+                    }
+                else:
+                    item = {"name": None}
+                    continue
+            if item["type"][0] == "f":
+                item["fields"][x.column_name] = x.reference_column
+            else:
+                item["fields"].append(x.column_name)
+        if item["name"]:
+            constraints.append(item)
+        return {
+            "table": f"{schema_name}.{table_name}" if schema_name else table_name,
+            "fields": fields,
+            "constraints": constraints
+        }
+
+    async def page(self, query, limit, offset):
+        query = f"{query}\nlimit {limit}"
+        if offset:
+            query = f"{query}\noffset {offset}"
+        return query
+
+    async def get_position(self, table, key, filter):
+        """
+        возвращает номер первой строки table, отсортированной по key, соответствующей фильтру filter
+        """
+        n_field = "co_lu_mn__po_si_ti_on__by__ke_y"
+        qry = f"""select row_number() over (order by {key}) {n_field}, t.* from {table} t"""
+        qry = f"""select {n_field} from ({qry}) x where {filter} order by {n_field}"""
+        x = await self.sql(qry, one_row=True, row_factory=RowFactory.TUPLE)
+        if x:
+            return x[0]

ab_engine/db/driver_mysql.py

@@ -0,0 +1,110 @@
+import sys, os
+sys.path.append(os.path.dirname(__file__))
+from driver import Driver as BaseDriver, RowFactory
+try:
+    from mysql.connector.aio import connect
+except ImportError:
+    raise Exception("For use MySQL driver, you need to install mysql.connector\n$ pip install mysql-connector-python")
+from collections import namedtuple
+
+def as_is(description, data):
+    return data
+
+def as_dict(description, data):
+    fields = [column[0] for column in description]
+    if isinstance(data, list):
+        for n, row in enumerate(data):
+            data[n] = {key: value for key, value in zip(fields, row)}
+        return data
+    return {key: value for key, value in zip(fields, data)}
+
+def as_namedtuple(description, data):
+    fields = [column[0].lower() for column in description]
+    cls = namedtuple("Row", fields)
+    if isinstance(data, list):
+        for n, row in enumerate(data):
+            data[n] = cls._make(row)
+        return data
+    return cls._make(data)
+
+_FACTORY_ = {
+    RowFactory.ANY.value: as_is,
+    RowFactory.TUPLE.value: as_is,
+    RowFactory.DICT.value: as_dict,
+    RowFactory.NAMED_TUPLE.value: as_namedtuple,
+}
+
+
+class Driver(BaseDriver):
+
+    def __init__(self, connection_string, on_open_close=None):
+        """
+        localhost:3306/mysql?user=root&password=root
+        """
+        if "{" in connection_string:
+            connection_string, options = connection_string.split("{", 1)
+
+        super().__init__(connection_string, on_open_close)
+
+        if "/" in self.connection_string:
+            x, options = self.connection_string.split("/", 1)
+        else:
+            x, options = self.connection_string.split("?", 1)
+        if ":" in x:
+            x, y = x.split(":")
+            self._conn_params = {
+                "host": x,
+                "port": int(y),
+            }
+        else:
+            self._conn_params = {
+                "host": x,
+                "port": 3306,
+            }
+        if "?" in options:
+            x, options = options.split("?",1)
+            self._conn_params["database"] = x
+        for x in options.split("&"):
+            k, v = x.split("=", 1)
+            self._conn_params[k] = v
+
+    async def begin(self):
+        await self._before_open()
+        self._conn = await connect(**self._conn_params)
+
+    async def sql(self, query, one_row=False, row_factory=RowFactory.DICT):
+        if self._conn is None:
+            await self.begin()
+        cur = await self._conn.cursor()
+        try:
+            await cur.execute(query)
+            descr = cur.description
+            if descr:
+                descr = descr.copy()
+                if one_row:
+                    data = await cur.fetchone()
+                else:
+                    data = await cur.fetchall()
+            else:
+                return cur.rowcount
+        finally:
+            try:
+                await cur.close()
+            except Exception as e:
+                pass
+        return _FACTORY_[row_factory.value](descr, data)
+
+    async def commit(self):
+        if not self._conn:
+            raise RuntimeError("Transaction is not open")
+        await self._conn.commit()
+        await self.rollback()
+
+    async def rollback(self):
+        if not self._conn:
+            return
+        if x := self._on_open_close:
+            await x(True)
+        await self._conn.close()
+        self._conn = None
+

ab_engine/db/driver_postgresql.py

@@ -0,0 +1,122 @@
+import sys, os
+sys.path.append(os.path.dirname(__file__))
+from driver import Driver as BaseDriver, RowFactory
+from psycopg import AsyncConnection
+import psycopg.rows as rows
+
+
+_FACTORY_ = {
+    RowFactory.ANY.value: rows.tuple_row,
+    RowFactory.TUPLE.value: rows.tuple_row,
+    RowFactory.DICT.value: rows.dict_row,
+    RowFactory.NAMED_TUPLE.value: rows.namedtuple_row,
+}
+
+def _col_type(col_type, type_cat):
+    if type_cat == "S":
+        return str
+    elif type_cat == "N":
+        if col_type in ("smallint", "integer", "bigint", "smallserial", "serial", "bigserial"):
+            return int
+        else:
+            return float
+    return str
+
+class Driver(BaseDriver):
+
+    LIKE = "ILIKE"
+
+    def __init__(self, connection_string, on_open_close=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
+
+    @property
+    def in_transaction(self):
+        return self._conn is not None
+
+    async def begin(self):
+        params = await self._before_open()
+        self._conn = await AsyncConnection.connect(self.connection_string)
+        for x in params:
+            if x == "TIMEZONE":
+                await self._conn.execute(f"set session timezone '{params[x]}'")
+            else:
+                await self._conn.execute(f"SET {x} = '{params[x]}'")
+
+    async def sql(self, query, one_row=False, row_factory=RowFactory.DICT):
+        if self._conn is None:
+            await self.begin()
+        async with self._conn.cursor() as acur:
+
+            acur.row_factory = _FACTORY_[row_factory.value]
+
+            await acur.execute(query)
+            descr = acur.description
+            if not descr:
+                return acur.rowcount
+            if one_row:
+                ret = await acur.fetchone()
+            else:
+                ret = await acur.fetchall()
+                if not ret:
+                    ret = []
+        return ret
+
+    async def commit(self):
+        if not self._conn:
+            raise RuntimeError("Transaction is not open")
+        await self._conn.commit()
+        await self.rollback()
+
+    async def rollback(self):
+        if not self._conn:
+            return
+        await self._conn.close()
+        await super().rollback()
+
+    @staticmethod
+    def _specify_type(defs):
+        if defs.column_default and str(defs.column_default).startswith("nextval("):
+            if defs.data_type == "integer":
+                return BaseDriver.TypeSpec(type_name="serial", python_type=int, autoincrement=True)
+            elif defs.data_type == "bigint":
+                return BaseDriver.TypeSpec(type_name="bigserial", python_type=int, autoincrement=True)
+            elif defs.data_type == "smallint":
+                return BaseDriver.TypeSpec(type_name="smallserial", python_type=int, autoincrement=True)
+        return BaseDriver._specify_type(defs)
+
+    @staticmethod
+    def ident_name(name: str) -> str:
+        """
+            Эмулирует поведение PostgreSQL функции quote_ident().
+            """
+        if name is None:
+            return "NULL"
+        # Проверяем, является ли строка валидным идентификатором
+        if (name[0].isalpha() or name[0] == '_') \
+                and all(char.isalnum() or char == '_' for char in name) \
+                and name == name.lower():
+            return name
+        # Удваиваем существующие двойные кавычки
+        name = name.replace('"', '""')
+        # Заключаем в двойные кавычки
+        return f'"{name}"'