lcdp-sqlalchemy-utils 1.5.8__tar.gz

lcdp_sqlalchemy_utils-1.5.8/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: lcdp-sqlalchemy-utils
+Version: 1.5.8
+Summary: SQLAlchemy Utils
+Author: Le Comptoir Des Pharmacies
+Author-email: webmaster@lecomptoirdespharmacies.fr
+Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: SQLAlchemy (==2.0.40)
+Requires-Dist: alembic (==1.8.1)
+Requires-Dist: dataclasses-json (==0.5.7)
+Requires-Dist: nest_asyncio (==1.5.8)

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/env.py

@@ -0,0 +1,64 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+
+def run_migrations_offline(**kwargs):
+  """Run migrations in 'offline' mode.
+
+  This configures the context with just a URL
+  and not an Engine, though an Engine is acceptable
+  here as well.  By skipping the Engine creation
+  we don't even need a DBAPI to be available.
+
+  Calls to context.execute() here emit the given string to the
+  script output.
+
+  """
+  url = config.get_main_option("sqlalchemy.url")
+  context.configure(
+    url=url,
+    literal_binds=True,
+    dialect_opts={"paramstyle": "named"},
+    **kwargs
+  )
+
+  with context.begin_transaction():
+    context.run_migrations()
+
+
+def run_migrations_online(db_url=None, **kwargs):
+  """Run migrations in 'online' mode.
+
+  In this scenario we need to create an Engine
+  and associate a connection with the context.
+
+  """
+  alembic_config = config.get_section(config.config_ini_section)
+  connectable = engine_from_config(
+    alembic_config,
+    url=db_url,
+    prefix="sqlalchemy.",
+    poolclass=pool.NullPool,
+  )
+
+  with connectable.connect() as connection:
+    # for compare_type=True, https://alembic.sqlalchemy.org/en/latest/autogenerate.html#comparing-types
+    context.configure(
+      connection=connection, compare_type=True, **kwargs
+    )
+
+    with context.begin_transaction():
+      context.run_migrations()

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/env_async.py

@@ -0,0 +1,73 @@
+import asyncio
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+from sqlalchemy.engine import Connection
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+
+async def run_migrations_offline(**kwargs):
+    """Run migrations in 'offline' mode.
+
+  This configures the context with just a URL
+  and not an Engine, though an Engine is acceptable
+  here as well.  By skipping the Engine creation
+  we don't even need a DBAPI to be available.
+
+  Calls to context.execute() here emit the given string to the
+  script output.
+
+  """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        **kwargs
+    )
+
+    async with context.begin_transaction():
+        context.run_migrations()
+
+
+def do_run_migrations(connection: Connection, **kwargs) -> None:
+    # target_metadata = MetaData()
+    context.configure(connection=connection, compare_type=True,  **kwargs)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+async def run_migrations_online(db_url=None, **kwargs):
+    """Run migrations in 'online' mode.
+
+  In this scenario we need to create an Engine
+  and associate a connection with the context.
+
+  """
+    alembic_config = config.get_section(config.config_ini_section)
+    connectable = AsyncEngine(
+        engine_from_config(
+            alembic_config,
+            url=db_url,
+            prefix="sqlalchemy.",
+            poolclass=pool.NullPool,
+            future=True,
+        )
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations, **kwargs)
+    await connectable.dispose()

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/exceptions/InvalidOrderByException.py

@@ -0,0 +1,3 @@
+# Raise this when arguments send from the client are invalid
+class InvalidOrderByException(Exception):
+    pass

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/migrate.py

@@ -0,0 +1,11 @@
+import os
+
+from alembic.config import Config
+from alembic import command
+
+# Upgrade migration
+# see https://alembic.sqlalchemy.org/en/latest/api/config.html
+def launch_migration_upgrade(alembic_config_path, db_url):
+    alembic_cfg = Config(alembic_config_path)
+    alembic_cfg.set_main_option("sqlalchemy.url", db_url)
+    command.upgrade(alembic_cfg, "head")

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/order_by_mapper.py

@@ -0,0 +1,26 @@
+from sqlalchemy import desc, asc
+from .exceptions.InvalidOrderByException import InvalidOrderByException
+
+
+def build(order_by_dto, dao_mapper):
+    if order_by_dto is None:
+        return None
+
+    to = []
+    for order_by in order_by_dto:
+        try:
+            parts = order_by.split(':', 2)
+            column = dao_mapper(parts[0])
+            to.append(__add_sorting_order(parts[1], column))
+        except IndexError as e:
+            raise InvalidOrderByException("Order by dto is invalid cannot be convert to sqlalchemy order by", e)
+    return to
+
+
+def __add_sorting_order(sorting_order, column):
+    if sorting_order.upper() == 'DESC':
+        return desc(column)
+    elif sorting_order.upper() == 'ASC':
+        return asc(column)
+    else:
+        raise InvalidOrderByException(f"{sorting_order.upper()} is neither ASC or DESC")

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/postgres.py

@@ -0,0 +1,214 @@
+import os
+from datetime import datetime, timezone, date
+
+import sqlalchemy as sa
+import sqlalchemy.types as types
+from dataclasses_json import dataclass_json
+from dataclasses_json.mm import TYPES, _IsoField
+from sqlalchemy import create_engine
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.asyncio import async_scoped_session
+from sqlalchemy.ext.asyncio import async_sessionmaker
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.orm import sessionmaker, scoped_session
+
+LOCAL_TIMEZONE = datetime.now(timezone.utc).astimezone().tzinfo
+# See : https://mike.depalatis.net/blog/sqlalchemy-timestamps.html
+class Timestamp(sa.types.TypeDecorator):
+    impl = sa.types.DateTime
+
+    cache_ok = True
+
+    def process_bind_param(self, value: datetime, dialect):
+        if value is None:
+            return None
+
+        if value.tzinfo is None:
+            value = value.astimezone(LOCAL_TIMEZONE)
+
+        value = value.astimezone(timezone.utc)
+
+        if self.timezone:
+            return value
+        else:
+            return value.replace(tzinfo=None)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+
+        return value.astimezone(timezone.utc)
+
+
+# Customize encoder/decoder to use isoformat to store datetime objects (See : https://github.com/lidatong/dataclasses-json/issues/332)
+TYPES[datetime] = _IsoField
+
+def JSONBDataclass(cls, many=False):
+    serializable_cls = dataclass_json(cls)
+    schema = serializable_cls.schema(many=many)
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+
+        return schema.dump(value)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+
+        return schema.load(value)
+
+    def coerce_compared_value(self, op, value):
+        return self.impl.coerce_compared_value(op, value)
+
+    return type(cls.__name__, (types.TypeDecorator,), {
+        "impl": JSONB,
+        "process_bind_param": process_bind_param,
+        "process_result_value": process_result_value,
+        "cache_ok": True,
+        "coerce_compared_value": coerce_compared_value,
+    })
+
+import json
+def json_serializer(x):
+    def default(obj):
+        """JSON serializer for objects not serializable by default json code"""
+
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()
+        raise TypeError("Type %s not serializable" % type(obj))
+
+    return json.dumps(x, default=default)
+
+class PostgresConnector(object):
+    def __init__(self, host, db_name, username, password,
+                 pool_size=None,
+                 max_overflow=None,
+                 pool_timeout=None,
+                 pool_recycle=None):
+        """
+        Args:
+            host: Database host
+            db_name: Database name
+            username: Database username
+            password: Database password
+            pool_size: Number of permanent connections (env: DB_POOL_SIZE, default: 5)
+                HikariCP equivalent: minimumIdle = 5
+            max_overflow: Max additional connections beyond pool_size (env: DB_MAX_OVERFLOW, default: 5)
+                HikariCP equivalent: maximumPoolSize - minimumIdle = 10 - 5 = 5
+            pool_timeout: Seconds to wait for a connection (env: DB_POOL_TIMEOUT, default: 30)
+                HikariCP equivalent: connectionTimeout (not set in current config, recommended: 30000ms)
+            pool_recycle: Seconds before recycling a connection (env: DB_POOL_RECYCLE, default: 480)
+                HikariCP equivalent: maxLifetime = 480000ms (8 minutes)
+        """
+        self.host = host
+        self.username = username
+        self.password = password
+        self.db_name = db_name
+        self.pool_size = pool_size if pool_size is not None else int(os.getenv('DB_POOL_SIZE', '5'))
+        self.max_overflow = max_overflow if max_overflow is not None else int(os.getenv('DB_MAX_OVERFLOW', '5'))
+        self.pool_timeout = pool_timeout if pool_timeout is not None else int(os.getenv('DB_POOL_TIMEOUT', '30'))
+        self.pool_recycle = pool_recycle if pool_recycle is not None else int(os.getenv('DB_POOL_RECYCLE', '480'))
+        self._engine = None
+        self._session_factory = None
+
+    def get_engine(self):
+        if not self._engine:
+            # https://docs.sqlalchemy.org/en/14/core/pooling.html#dealing-with-disconnects
+            self._engine = create_engine(self.get_url(),
+                                         pool_pre_ping=True,
+                                         pool_size=self.pool_size,
+                                         max_overflow=self.max_overflow,
+                                         pool_timeout=self.pool_timeout,
+                                         pool_recycle=self.pool_recycle,
+                                         pool_use_lifo=True,
+                                         connect_args={},
+                                         json_serializer=json_serializer
+                                         )
+
+        return self._engine
+
+    def get_scoped_session(self, _ident_func):
+        return scoped_session(self.get_session_factory(), scopefunc=_ident_func)
+
+    def get_session_factory(self):
+        if not self._session_factory:
+            self._session_factory = sessionmaker(bind=self.get_engine())
+        return self._session_factory
+
+    def get_url(self) -> str:
+        return "postgresql+psycopg2://{}:{}@{}/{}".format(
+            self.username,
+            self.password,
+            self.host,
+            self.db_name
+        )
+
+
+class AsyncPostgresConnector(object):
+    def __init__(self, host, db_name, username, password,
+                 pool_size=None,
+                 max_overflow=None,
+                 pool_timeout=None,
+                 pool_recycle=None):
+        """
+        Args:
+            host: Database host
+            db_name: Database name
+            username: Database username
+            password: Database password
+            pool_size: Number of permanent connections (env: DB_POOL_SIZE, default: 5)
+                HikariCP equivalent: minimumIdle = 5
+            max_overflow: Max additional connections beyond pool_size (env: DB_MAX_OVERFLOW, default: 5)
+                HikariCP equivalent: maximumPoolSize - minimumIdle = 10 - 5 = 5
+            pool_timeout: Seconds to wait for a connection (env: DB_POOL_TIMEOUT, default: 30)
+                HikariCP equivalent: connectionTimeout (not set in current config, recommended: 30000ms)
+            pool_recycle: Seconds before recycling a connection (env: DB_POOL_RECYCLE, default: 480)
+                HikariCP equivalent: maxLifetime = 480000ms (8 minutes)
+        """
+        self.host = host
+        self.username = username
+        self.password = password
+        self.db_name = db_name
+        self.pool_size = pool_size if pool_size is not None else int(os.getenv('DB_POOL_SIZE', '5'))
+        self.max_overflow = max_overflow if max_overflow is not None else int(os.getenv('DB_MAX_OVERFLOW', '5'))
+        self.pool_timeout = pool_timeout if pool_timeout is not None else int(os.getenv('DB_POOL_TIMEOUT', '30'))
+        self.pool_recycle = pool_recycle if pool_recycle is not None else int(os.getenv('DB_POOL_RECYCLE', '480'))
+        self._engine = None
+        self._session_factory = None
+
+    def get_engine(self):
+        if not self._engine:
+            # https://docs.sqlalchemy.org/en/14/core/pooling.html#dealing-with-disconnects
+            self._engine = create_async_engine(self.get_url(),
+                                               pool_pre_ping=True,
+                                               pool_size=self.pool_size,
+                                               max_overflow=self.max_overflow,
+                                               pool_timeout=self.pool_timeout,
+                                               pool_recycle=self.pool_recycle,
+                                               pool_use_lifo=True,
+                                               connect_args={},
+                                               json_serializer=json_serializer
+                                               )
+
+        return self._engine
+
+    def get_scoped_session(self, _ident_func):
+        return async_scoped_session(self.get_session_factory(), scopefunc=_ident_func)
+
+    def get_session_factory(self):
+        if not self._session_factory:
+            self._session_factory = async_sessionmaker(bind=self.get_engine())
+        return self._session_factory
+
+    def get_url(self) -> str:
+        return "postgresql+asyncpg://{}:{}@{}/{}".format(
+            self.username,
+            self.password,
+            self.host,
+            self.db_name
+        )

lcdp_sqlalchemy_utils-1.5.8/lcdp_sqlalchemy_utils/query_executor.py

@@ -0,0 +1,116 @@
+from sqlalchemy import func
+import asyncio
+import nest_asyncio
+
+# Avoid RuntimeError: This event loop is already running
+# https://github.com/erdewit/nest_asyncio
+nest_asyncio.apply()
+
+
+class SearchResult:
+    _items: list
+    _total_found: int
+    _total_visible: int
+
+    def __init__(self, items=None, total_visible=None, total_found=None):
+        self._items = items
+        self._total_visible = total_visible
+        self._total_found = total_found
+
+    @property
+    def items(self):
+        return self._items
+
+    @items.setter
+    def items(self, items):
+        self._items = items
+
+    @property
+    def total_visible(self):
+        return self._total_visible
+
+    @total_visible.setter
+    def total_visible(self, total_visible):
+        self._total_visible = total_visible
+
+    @property
+    def total_found(self):
+        return self._total_found
+
+    @total_found.setter
+    def total_found(self, total_found):
+        self._total_found = total_found
+
+
+class QueryExecutor:
+    def __init__(self, model):
+        self._model = model
+
+    async def __get_query_count(self, query):
+        counter = query.statement.with_only_columns(func.count()).select_from(self._model).order_by(None)
+        return query.session.execute(counter).scalar()
+
+    @staticmethod
+    async def __get_query_result(query):
+        return query.all()
+
+    async def __execute(self, query, order_bys, page, limit):
+        if not page:
+            page = 0
+        if not order_bys:
+            order_bys = []
+
+        count_query = query
+        if order_bys:
+            query = query.order_by(*order_bys)
+
+        if limit:
+            query = query.limit(limit).offset(page * limit)
+
+        async with asyncio.TaskGroup() as tg:
+            items_task = tg.create_task(self.__get_query_result(query))
+            count_task = tg.create_task(self.__get_query_count(count_query))
+        return SearchResult(items_task.result(), count_task.result(), count_task.result())
+
+    def execute(self, query, order_bys=None, page=None, limit=None):
+        return asyncio.run(self.__execute(query, order_bys, page, limit))
+
+
+class QueryExecutorAsync:
+    def __init__(self, model):
+        self._model = model
+
+    async def __get_query_count(self, get_db_session, query):
+        counter = query.with_only_columns(func.count()).select_from(self._model).order_by(None)
+        result = await get_db_session().execute(counter)
+        return result.scalar_one()
+
+    @staticmethod
+    async def __get_query_result(get_db_session, query):
+        result = await get_db_session().execute(query)
+        return result.scalars().all()
+
+    async def __execute(self, get_db_session, query, order_bys, page, limit):
+        if not page:
+            page = 0
+        if not order_bys:
+            order_bys = []
+
+        count_query = query
+        if order_bys:
+            query = query.order_by(*order_bys)
+
+        if limit:
+            query = query.limit(limit).offset(page * limit)
+
+        async with asyncio.TaskGroup() as tg:
+            count_task = tg.create_task(self.__get_query_count(get_db_session, count_query))
+            items = await self.__get_query_result(get_db_session, query)
+        # Important note : As count is run in a parallel task, the returned value will not take into account modifications
+        # of DB state in the current task session (ex : object have been updated before, without transaction commit)
+        await asyncio.shield(count_task)
+        return SearchResult(items, count_task.result(), count_task.result())
+
+    # Pass get_db_session as a method because we need to call two distinct session for counts and values
+    async def execute(self, get_db_session, query, order_bys=None, page=None, limit=None):
+        return await self.__execute(get_db_session, query, order_bys, page, limit)

lcdp_sqlalchemy_utils-1.5.8/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "lcdp-sqlalchemy-utils"
+# https://github.com/python-poetry/poetry/issues/1208
+version = "1.5.8"
+description = "SQLAlchemy Utils"
+authors = ["Le Comptoir Des Pharmacies <webmaster@lecomptoirdespharmacies.fr>"]
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+
+[tool.poetry.requires-plugins]
+poetry-dynamic-versioning = { version = ">=1.0.0,<2.0.0", extras = ["plugin"] }
+
+[tool.poetry.dependencies]
+python = ">=3.8"
+SQLAlchemy = "2.0.40"
+alembic="1.8.1"
+dataclasses-json = "0.5.7"
+nest_asyncio = "1.5.8"
+
+[tool.poetry.dev-dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
+build-backend = "poetry_dynamic_versioning.backend"