rucio 32.8.6__py3-none-any.whl → 35.8.0__py3-none-any.whl

rucio/db/sqla/session.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,19 +18,19 @@ import os
 import sys
 from datetime import datetime, timedelta
 from functools import update_wrapper
-from inspect import isgeneratorfunction, getfullargspec
+from inspect import getfullargspec, isgeneratorfunction
 from os.path import basename
-from time import sleep
 from threading import Lock
-from typing import TYPE_CHECKING
+from time import sleep
+from typing import TYPE_CHECKING, Any, Union
 
-from sqlalchemy import create_engine, event, MetaData, text
-from sqlalchemy.exc import DatabaseError, DisconnectionError, OperationalError, TimeoutError, SQLAlchemyError
-from sqlalchemy.orm import DeclarativeBase, sessionmaker, scoped_session, Session
-from sqlalchemy.pool import QueuePool, SingletonThreadPool, NullPool
+from sqlalchemy import MetaData, create_engine, event, text
+from sqlalchemy.exc import DatabaseError, DisconnectionError, OperationalError, SQLAlchemyError, TimeoutError
+from sqlalchemy.orm import DeclarativeBase, Session, scoped_session, sessionmaker
+from sqlalchemy.pool import NullPool, Pool, QueuePool, SingletonThreadPool
 
 from rucio.common.config import config_get
-from rucio.common.exception import RucioException, DatabaseException, InputValidationError
+from rucio.common.exception import DatabaseException, InputValidationError, RucioException
 from rucio.common.extra import import_extras
 from rucio.common.utils import retrying
 
@@ -41,8 +40,14 @@ if TYPE_CHECKING:
     from collections.abc import Callable
     from typing import Optional, ParamSpec, TypeVar
 
+    from pymysql import Connection as MySQLConnection
+    from sqlalchemy.engine.base import Engine
+
+    from rucio.common.types import LoggerFunction
+
     P = ParamSpec('P')
     R = TypeVar('R')
+    CallableTypeVar = TypeVar('CallableTypeVar', bound='Callable[..., Any]')
 
 
 try:
@@ -70,7 +75,7 @@ class BASE(DeclarativeBase):
     metadata = _METADATA
 
 
-def _fk_pragma_on_connect(dbapi_con, con_record):
+def _fk_pragma_on_connect(dbapi_con, con_record) -> None:
     # Hack for previous versions of sqlite3
     try:
         dbapi_con.execute('pragma foreign_keys=ON')
@@ -78,7 +83,11 @@ def _fk_pragma_on_connect(dbapi_con, con_record):
         pass
 
 
-def mysql_ping_listener(dbapi_conn, connection_rec, connection_proxy):
+def mysql_ping_listener(
+        dbapi_conn: "MySQLConnection",
+        connection_rec,
+        connection_proxy
+) -> None:
     """
     Ensures that MySQL connections checked out of the
     pool are alive.
@@ -101,7 +110,9 @@ def mysql_ping_listener(dbapi_conn, connection_rec, connection_proxy):
             raise
 
 
-def mysql_convert_decimal_to_float(pymysql=False):
+def mysql_convert_decimal_to_float(
+        pymysql: bool = False
+) -> dict[Union[type[object], int], 'Callable[..., Any]']:
     """
     The default datatype returned by mysql-python for numerics is decimal.Decimal.
     This type cannot be serialised to JSON, therefore we need to autoconvert to floats.
@@ -111,7 +122,7 @@ def mysql_convert_decimal_to_float(pymysql=False):
     :return converter: Converter object
     """
 
-    def pymysql_converter():
+    def pymysql_converter() -> dict[Union[type[object], int], 'Callable[..., Any]']:
         from pymysql.constants import FIELD_TYPE
         from pymysql.converters import conversions as conv
         converter = conv.copy()
@@ -138,7 +149,7 @@ def mysql_convert_decimal_to_float(pymysql=False):
     return converter
 
 
-def psql_convert_decimal_to_float(dbapi_conn, connection_rec):
+def psql_convert_decimal_to_float(dbapi_conn, connection_rec) -> None:
     """
     The default datatype returned by psycopg2 for numerics is decimal.Decimal.
     This type cannot be serialised to JSON, therefore we need to autoconvert to floats.
@@ -158,8 +169,8 @@ def psql_convert_decimal_to_float(dbapi_conn, connection_rec):
     psycopg2.extensions.register_type(DEC2FLOAT)
 
 
-def my_on_connect(dbapi_con, connection_record):
-    """ Adds information to track performance and ressource by module.
+def my_on_connect(dbapi_con, connection_record) -> None:
+    """ Adds information to track performance and resource by module.
         Info are recorded in the V$SESSION and V$SQLAREA views.
     """
     caller = basename(sys.argv[0])
@@ -169,7 +180,7 @@ def my_on_connect(dbapi_con, connection_record):
     dbapi_con.action = caller
 
 
-def _get_engine_poolclass(poolclass):
+def _get_engine_poolclass(poolclass: str) -> Pool:
     """Resolve the correct SQLAlchemy Pool type to use from the
     poolclass config option.
 
@@ -192,7 +203,7 @@ def _get_engine_poolclass(poolclass):
     return SQLA_CONFIG_POOLCLASS_MAPPING[poolclass]
 
 
-def get_engine():
+def get_engine() -> 'Engine':
     """ Creates a engine to a specific database.
         :returns: engine
     """
@@ -223,11 +234,14 @@ def get_engine():
             event.listen(_ENGINE, 'connect', _fk_pragma_on_connect)
         elif 'oracle' in sql_connection:
             event.listen(_ENGINE, 'connect', my_on_connect)
-    assert _ENGINE
+    if not _ENGINE:
+        raise RuntimeError("Could not form database engine.")
     return _ENGINE
 
 
-def get_dump_engine(echo=False):
+def get_dump_engine(
+        echo: bool = False
+) -> 'Engine':
     """ Creates a dump engine to a specific database.
         :returns: engine """
 
@@ -253,20 +267,21 @@ def get_dump_engine(echo=False):
     return engine
 
 
-def get_maker():
+def get_maker() -> sessionmaker:
     """
         Return a SQLAlchemy sessionmaker.
         May assign __MAKER if not already assigned.
     """
     global _MAKER, _ENGINE
-    assert _ENGINE
+    if not _ENGINE:
+        raise RuntimeError("Could not form database engine.")
     if not _MAKER:
         # turn on sqlAlchemy 2.0 with future=True.
         _MAKER = sessionmaker(bind=_ENGINE, autocommit=False, autoflush=True, expire_on_commit=True, future=True)
     return _MAKER
 
 
-def get_session():
+def get_session() -> scoped_session:
     """ Creates a session to a specific database, assumes that schema already in place.
         :returns: session
     """
@@ -278,12 +293,18 @@ def get_session():
             get_maker()
         finally:
             _LOCK.release()
-    assert _MAKER
+    if not _MAKER:
+        raise RuntimeError("Session factory is not defined.")
     session = scoped_session(_MAKER)
     return session
 
 
-def wait_for_database(timeout: int = 60, interval: int = 2, *, logger=logging.log):
+def wait_for_database(
+        timeout: int = 60,
+        interval: int = 2,
+        *,
+        logger: "LoggerFunction" = logging.log
+) -> None:
     """ Wait for the database for a specific amount of time """
 
     end_time = datetime.utcnow() + timedelta(seconds=timeout)
@@ -304,7 +325,7 @@ def wait_for_database(timeout: int = 60, interval: int = 2, *, logger=logging.lo
         sleep(interval)
 
 
-def retry_if_db_connection_error(exception):
+def retry_if_db_connection_error(exception: Exception) -> bool:
     """Return True if error in connecting to db."""
     if isinstance(exception, (OperationalError, DatabaseException)):
         conn_err_codes = ('2002', '2003', '2006',  # MySQL
@@ -320,11 +341,14 @@ def retry_if_db_connection_error(exception):
     return False
 
 
-def _update_session_wrapper(wrapper, wrapped):
+def _update_session_wrapper(
+        wrapper: "CallableTypeVar",
+        wrapped: 'Callable'
+) -> "CallableTypeVar":
     """
     In addition to the work done by functools.update_wrapper, this function also preservers
     the signature of the initial function. With the exception that the 'session' parameter
-    is overriden to have a default value of 'None'.
+    is overridden to have a default value of 'None'.
 
     wrapper is the function to be updated
     wrapped is the original function
@@ -373,17 +397,17 @@ def read_session(function: "Callable[P, R]"):
         if not session:
             session_scoped = get_session()
             session = session_scoped()
-            session.begin()
+            session.begin()  # type: ignore
             try:
                 return function(*args, session=session, **kwargs)
             except TimeoutError as error:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise DatabaseException(str(error))
             except DatabaseError as error:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise DatabaseException(str(error))
             except:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise
             finally:
                 session_scoped.remove()
@@ -414,18 +438,18 @@ def stream_session(function: "Callable[P, R]"):
         if not session:
             session_scoped = get_session()
             session = session_scoped()
-            session.begin()
+            session.begin()  # type: ignore
             try:
                 for row in function(*args, session=session, **kwargs):
                     yield row
             except TimeoutError as error:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise DatabaseException(str(error))
             except DatabaseError as error:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise DatabaseException(str(error))
             except:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise
             finally:
                 session_scoped.remove()
@@ -438,29 +462,33 @@ def stream_session(function: "Callable[P, R]"):
     return _update_session_wrapper(new_funct, function)
 
 
-def transactional_session(function: "Callable[P, R]"):
+def transactional_session(function: "Callable[P, R]") -> 'Callable':
     '''
     decorator that set the session variable to use inside a function.
     With that decorator it's possible to use the session variable like if a global variable session is declared.
 
     session is a sqlalchemy session, and you can get one calling get_session().
     '''
-    def new_funct(*args: "P.args", session: "Optional[Session]" = None, **kwargs):  # pylint:disable=missing-kwoa
+    def new_funct(
+            *args: "P.args",
+            session: "Optional[Session]" = None,
+            **kwargs
+    ) -> "R":  # pylint:disable=missing-kwoa
         if not session:
             session_scoped = get_session()
             session = session_scoped()
-            session.begin()
+            session.begin()  # type: ignore
             try:
                 result = function(*args, session=session, **kwargs)
-                session.commit()  # pylint: disable=maybe-no-member
+                session.commit()  # type: ignore
             except TimeoutError as error:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise DatabaseException(str(error))
             except DatabaseError as error:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise DatabaseException(str(error))
             except:
-                session.rollback()  # pylint: disable=maybe-no-member
+                session.rollback()  # type: ignore
                 raise
             finally:
                 session_scoped.remove()  # pylint: disable=maybe-no-member

rucio/db/sqla/types.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,10 +16,10 @@ import uuid
 
 import sqlalchemy.types as types
 from sqlalchemy.dialects.mysql import BINARY
-from sqlalchemy.dialects.oracle import RAW, CLOB
-from sqlalchemy.dialects.postgresql import UUID, JSONB
+from sqlalchemy.dialects.oracle import CLOB, RAW
+from sqlalchemy.dialects.postgresql import JSONB, UUID
 from sqlalchemy.sql import operators
-from sqlalchemy.types import TypeDecorator, CHAR, String
+from sqlalchemy.types import CHAR, String, TypeDecorator
 
 from rucio.common.exception import InvalidType
 from rucio.common.types import InternalAccount, InternalScope

rucio/db/sqla/util.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,17 +16,17 @@ import logging
 from datetime import datetime
 from hashlib import sha256
 from os import urandom
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 import sqlalchemy
 from alembic import command, op
 from alembic.config import Config
 from dogpile.cache.api import NoValue
-from sqlalchemy import func, inspect, Column, PrimaryKeyConstraint
+from sqlalchemy import Column, PrimaryKeyConstraint, func, inspect
 from sqlalchemy.dialects.postgresql.base import PGInspector
-from sqlalchemy.exc import IntegrityError, DatabaseError
+from sqlalchemy.exc import DatabaseError, IntegrityError
 from sqlalchemy.orm import declarative_base
-from sqlalchemy.schema import CreateSchema, MetaData, Table, CreateTable, DropTable, ForeignKeyConstraint, DropConstraint
+from sqlalchemy.schema import CreateSchema, CreateTable, DropConstraint, DropTable, ForeignKeyConstraint, MetaData, Table
 from sqlalchemy.sql.ddl import DropSchema
 from sqlalchemy.sql.expression import select, text
 
@@ -35,22 +34,26 @@ from rucio import alembicrevision
 from rucio.common.cache import make_region_memcached
 from rucio.common.config import config_get, config_get_list
 from rucio.common.schema import get_schema_value
-from rucio.common.types import InternalAccount
+from rucio.common.types import InternalAccount, LoggerFunction
 from rucio.common.utils import generate_uuid
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import AccountStatus, AccountType, IdentityType
-from rucio.db.sqla.session import get_engine, get_session, get_dump_engine
+from rucio.db.sqla.session import get_dump_engine, get_engine, get_session
 from rucio.db.sqla.types import InternalScopeString, String
 
 if TYPE_CHECKING:
-    from typing import Optional, Union  # noqa: F401
-    from sqlalchemy.orm import Session  # noqa: F401
-    from sqlalchemy.engine import Inspector  # noqa: F401
+    from collections.abc import Sequence
+
+    from sqlalchemy.engine import Inspector
+    from sqlalchemy.orm import Query, Session
+
+    # TypeVar representing the DeclarativeObj class defined inside _create_temp_table
+    DeclarativeObj = TypeVar('DeclarativeObj')
 
 REGION = make_region_memcached(expiration_time=600, memcached_expire_time=3660)
 
 
-def build_database():
+def build_database() -> None:
     """ Applies the schema to the database. Run this command once to build the database. """
     engine = get_engine()
 
@@ -71,13 +74,13 @@ def build_database():
     command.stamp(alembic_cfg, "head")
 
 
-def dump_schema():
+def dump_schema() -> None:
     """ Creates a schema dump to a specific database. """
     engine = get_dump_engine()
     models.register_models(engine)
 
 
-def destroy_database():
+def destroy_database() -> None:
     """ Removes the schema from the database. Only useful for test cases or malicious intents. """
     engine = get_engine()
 
@@ -87,7 +90,7 @@ def destroy_database():
         print('Cannot destroy schema -- assuming already gone, continuing:', e)
 
 
-def drop_everything():
+def drop_everything() -> None:
     """
     Pre-gather all named constraints and table names, and drop everything.
     This is better than using metadata.reflect(); metadata.drop_all()
@@ -101,7 +104,7 @@ def drop_everything():
 
     with engine.connect() as conn:
 
-        inspector = inspect(conn)  # type: Union[Inspector, PGInspector]
+        inspector: Union["Inspector", PGInspector] = inspect(conn)
 
         for tname, fkcs in reversed(
                 inspector.get_sorted_table_and_fkc_names(schema='*')):
@@ -122,12 +125,13 @@ def drop_everything():
             conn.execute(DropSchema(schema, cascade=True))
 
         if engine.dialect.name == 'postgresql':
-            assert isinstance(inspector, PGInspector), 'expected a PGInspector'
+            if not isinstance(inspector, PGInspector):
+                raise ValueError('expected a PGInspector')
             for enum in inspector.get_enums(schema='*'):
                 sqlalchemy.Enum(**enum).drop(bind=conn)
 
 
-def create_base_vo():
+def create_base_vo() -> None:
     """ Creates the base VO """
 
     session_scoped = get_session()
@@ -138,40 +142,28 @@ def create_base_vo():
             s.add_all([vo])
 
 
-def create_root_account():
+def create_root_account() -> None:
     """
     Inserts the default root account to an existing database. Make sure to change the default password later.
     """
 
     multi_vo = bool(config_get('common', 'multi_vo', False, False))
 
-    up_id = 'ddmlab'
-    up_pwd = 'secret'
-    up_email = 'ph-adp-ddm-lab@cern.ch'
-    x509_id = 'emailAddress=ph-adp-ddm-lab@cern.ch,CN=DDMLAB Client Certificate,OU=PH-ADP-CO,O=CERN,ST=Geneva,C=CH'
-    x509_email = 'ph-adp-ddm-lab@cern.ch'
-    gss_id = 'ddmlab@CERN.CH'
-    gss_email = 'ph-adp-ddm-lab@cern.ch'
-    ssh_id = 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq5LySllrQFpPL614sulXQ7wnIr1aGhGtl8b+HCB/'\
-             '0FhMSMTHwSjX78UbfqEorZV16rXrWPgUpvcbp2hqctw6eCbxwqcgu3uGWaeS5A0iWRw7oXUh6ydn'\
-             'Vy89zGzX1FJFFDZ+AgiZ3ytp55tg1bjqqhK1OSC0pJxdNe878TRVVo5MLI0S/rZY2UovCSGFaQG2'\
-             'iLj14wz/YqI7NFMUuJFR4e6xmNsOP7fCZ4bGMsmnhR0GmY0dWYTupNiP5WdYXAfKExlnvFLTlDI5'\
-             'Mgh4Z11NraQ8pv4YE1woolYpqOc/IMMBBXFniTT4tC7cgikxWb9ZmFe+r4t6yCDpX4IL8L5GOQ== ddmlab'
-    ssh_email = 'ph-adp-ddm-lab@cern.ch'
-
-    try:
-        up_id = config_get('bootstrap', 'userpass_identity')
-        up_pwd = config_get('bootstrap', 'userpass_pwd')
-        up_email = config_get('bootstrap', 'userpass_email')
-        x509_id = config_get('bootstrap', 'x509_identity')
-        x509_email = config_get('bootstrap', 'x509_email')
-        gss_id = config_get('bootstrap', 'gss_identity')
-        gss_email = config_get('bootstrap', 'gss_email')
-        ssh_id = config_get('bootstrap', 'ssh_identity')
-        ssh_email = config_get('bootstrap', 'ssh_email')
-    except:
-        pass
-        # print 'Config values are missing (check rucio.cfg{.template}). Using hardcoded defaults.'
+    up_id = config_get('bootstrap', 'userpass_identity', default='ddmlab')
+    up_pwd = config_get('bootstrap', 'userpass_pwd', default='secret')
+    up_email = config_get('bootstrap', 'userpass_email', default='ph-adp-ddm-lab@cern.ch')
+    x509_id = config_get('bootstrap', 'x509_identity', default='emailAddress=ph-adp-ddm-lab@cern.ch,CN=DDMLAB Client Certificate,OU=PH-ADP-CO,O=CERN,ST=Geneva,C=CH')
+    x509_email = config_get('bootstrap', 'x509_email', default='ph-adp-ddm-lab@cern.ch')
+    gss_id = config_get('bootstrap', 'gss_identity', default='ddmlab@CERN.CH')
+    gss_email = config_get('bootstrap', 'gss_email', default='ph-adp-ddm-lab@cern.ch')
+    ssh_id = config_get('bootstrap', 'ssh_identity',
+                        default='ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq5LySllrQFpPL614sulXQ7wnIr1aGhGtl8b+HCB/'
+                        '0FhMSMTHwSjX78UbfqEorZV16rXrWPgUpvcbp2hqctw6eCbxwqcgu3uGWaeS5A0iWRw7oXUh6ydn'
+                        'Vy89zGzX1FJFFDZ+AgiZ3ytp55tg1bjqqhK1OSC0pJxdNe878TRVVo5MLI0S/rZY2UovCSGFaQG2'
+                        'iLj14wz/YqI7NFMUuJFR4e6xmNsOP7fCZ4bGMsmnhR0GmY0dWYTupNiP5WdYXAfKExlnvFLTlDI5'
+                        'Mgh4Z11NraQ8pv4YE1woolYpqOc/IMMBBXFniTT4tC7cgikxWb9ZmFe+r4t6yCDpX4IL8L5GOQ== ddmlab'
+                        )
+    ssh_email = config_get('bootstrap', 'ssh_email', default='ph-adp-ddm-lab@cern.ch')
 
     session_scoped = get_session()
 
@@ -185,25 +177,41 @@ def create_root_account():
     salt = urandom(255)
     salted_password = salt + up_pwd.encode()
     hashed_password = sha256(salted_password).hexdigest()
-    identity1 = models.Identity(identity=up_id, identity_type=IdentityType.USERPASS, password=hashed_password, salt=salt, email=up_email)
-    iaa1 = models.IdentityAccountAssociation(identity=identity1.identity, identity_type=identity1.identity_type, account=account.account, is_default=True)
+
+    identities = []
+    associations = []
+
+    if up_id and up_pwd:
+        identity1 = models.Identity(identity=up_id, identity_type=IdentityType.USERPASS, password=hashed_password, salt=salt, email=up_email)
+        iaa1 = models.IdentityAccountAssociation(identity=identity1.identity, identity_type=identity1.identity_type, account=account.account, is_default=True)
+        identities.append(identity1)
+        associations.append(iaa1)
 
     # X509 authentication
-    identity2 = models.Identity(identity=x509_id, identity_type=IdentityType.X509, email=x509_email)
-    iaa2 = models.IdentityAccountAssociation(identity=identity2.identity, identity_type=identity2.identity_type, account=account.account, is_default=True)
+    if x509_id and x509_email:
+        identity2 = models.Identity(identity=x509_id, identity_type=IdentityType.X509, email=x509_email)
+        iaa2 = models.IdentityAccountAssociation(identity=identity2.identity, identity_type=identity2.identity_type, account=account.account, is_default=True)
+        identities.append(identity2)
+        associations.append(iaa2)
 
     # GSS authentication
-    identity3 = models.Identity(identity=gss_id, identity_type=IdentityType.GSS, email=gss_email)
-    iaa3 = models.IdentityAccountAssociation(identity=identity3.identity, identity_type=identity3.identity_type, account=account.account, is_default=True)
+    if gss_id and gss_email:
+        identity3 = models.Identity(identity=gss_id, identity_type=IdentityType.GSS, email=gss_email)
+        iaa3 = models.IdentityAccountAssociation(identity=identity3.identity, identity_type=identity3.identity_type, account=account.account, is_default=True)
+        identities.append(identity3)
+        associations.append(iaa3)
 
     # SSH authentication
-    identity4 = models.Identity(identity=ssh_id, identity_type=IdentityType.SSH, email=ssh_email)
-    iaa4 = models.IdentityAccountAssociation(identity=identity4.identity, identity_type=identity4.identity_type, account=account.account, is_default=True)
+    if ssh_id and ssh_email:
+        identity4 = models.Identity(identity=ssh_id, identity_type=IdentityType.SSH, email=ssh_email)
+        iaa4 = models.IdentityAccountAssociation(identity=identity4.identity, identity_type=identity4.identity_type, account=account.account, is_default=True)
+        identities.append(identity4)
+        associations.append(iaa4)
 
     with session_scoped() as s:
         s.begin()
         # Apply
-        for identity in [identity1, identity2, identity3, identity4]:
+        for identity in identities:
             try:
                 s.add(identity)
                 s.commit()
@@ -212,11 +220,11 @@ def create_root_account():
                 s.rollback()
         s.add(account)
         s.flush()
-        s.add_all([iaa1, iaa2, iaa3, iaa4])
+        s.add_all(associations)
         s.commit()
 
 
-def get_db_time():
+def get_db_time() -> Optional[datetime]:
     """ Gives the utc time on the db. """
     session_scoped = get_session()
     try:
@@ -241,7 +249,7 @@ def get_db_time():
         session_scoped.remove()
 
 
-def get_count(q):
+def get_count(q: "Query") -> int:
     """
     Fast way to get count in SQLAlchemy
     Source: https://gist.github.com/hest/8798884
@@ -253,7 +261,7 @@ def get_count(q):
     return count
 
 
-def is_old_db():
+def is_old_db() -> bool:
     """
     Returns true, if alembic is used and the database is not on the
     same revision as the code base.
@@ -274,7 +282,7 @@ def is_old_db():
             return (len(query) != 0 and str(query[0].version_num) != alembicrevision.ALEMBIC_REVISION)
 
 
-def json_implemented(*, session=None):
+def json_implemented(*, session: Optional["Session"] = None) -> bool:
     """
     Checks if the database on the current server installation can support json fields.
 
@@ -295,7 +303,7 @@ def json_implemented(*, session=None):
     return True
 
 
-def try_drop_constraint(constraint_name, table_name):
+def try_drop_constraint(constraint_name: str, table_name: str) -> None:
     """
     Tries to drop the given constrained and returns successfully if the
     constraint already existed on Oracle databases.
@@ -306,10 +314,11 @@ def try_drop_constraint(constraint_name, table_name):
     try:
         op.drop_constraint(constraint_name, table_name)
     except DatabaseError as e:
-        assert 'nonexistent constraint' in str(e)
+        if 'nonexistent constraint' not in str(e):
+            raise RuntimeError(e)
 
 
-def list_oracle_global_temp_tables(session):
+def list_oracle_global_temp_tables(session: "Session") -> list[str]:
     """
     Retrieve the list of global temporary tables in oracle
     """
@@ -338,7 +347,14 @@ def list_oracle_global_temp_tables(session):
     return global_temp_tables
 
 
-def _create_temp_table(name, *columns, primary_key=None, oracle_global_name=None, session=None, logger=logging.log):
+def _create_temp_table(
+        name: str,
+        *columns: "Sequence[Column]",
+        primary_key: Optional["Sequence[Any]"] = None,
+        oracle_global_name: Optional[str] = None,
+        session: Optional["Session"] = None,
+        logger: LoggerFunction = logging.log
+) -> type["DeclarativeObj"]:
     """
     Create a temporary table with the given columns, register it into a declarative base, and return it.
 
@@ -366,7 +382,7 @@ def _create_temp_table(name, *columns, primary_key=None, oracle_global_name=None
     oracle_table_is_global = False
     if session.bind.dialect.name == 'oracle':
         # Retrieve the list of global temporary tables on oracle.
-        # If the requested table is found to be global, re-use it,
+        # If the requested table is found to be global, reuse it,
         # otherwise create a private temporary table with random name
         global_temp_tables = list_oracle_global_temp_tables(session=session)
         if oracle_global_name is None:
@@ -452,18 +468,24 @@ class TempTableManager:
     sessions in multiple threads at a time, so no need to protect indexes with a mutex.
     """
 
-    def __init__(self, session):
+    def __init__(self, session: "Session"):
         self.session = session
 
         self.next_idx_to_use = {}
 
-    def create_temp_table(self, name, *columns, primary_key=None, logger=logging.log):
+    def create_temp_table(
+            self,
+            name: str,
+            *columns: "Sequence[Column]",
+            primary_key: Optional["Sequence[Any]"] = None,
+            logger: LoggerFunction = logging.log
+    ) -> type["DeclarativeObj"]:
         idx = self.next_idx_to_use.setdefault(name, 0)
         table = _create_temp_table(f'{name}_{idx}', *columns, primary_key=primary_key, session=self.session, logger=logger)
         self.next_idx_to_use[name] = idx + 1
         return table
 
-    def create_scope_name_table(self, logger=logging.log):
+    def create_scope_name_table(self, logger: LoggerFunction = logging.log) -> type["DeclarativeObj"]:
         """
         Create a temporary table with columns 'scope' and 'name'
         """
@@ -479,7 +501,7 @@ class TempTableManager:
             logger=logger,
         )
 
-    def create_association_table(self, logger=logging.log):
+    def create_association_table(self, logger: LoggerFunction = logging.log) -> type["DeclarativeObj"]:
         """
         Create a temporary table with columns 'scope', 'name', 'child_scope'and 'child_name'
         """
@@ -497,7 +519,7 @@ class TempTableManager:
             logger=logger,
         )
 
-    def create_id_table(self, logger=logging.log):
+    def create_id_table(self, logger: LoggerFunction = logging.log) -> type["DeclarativeObj"]:
         """
         Create a temp table with a single id column of uuid type
         """