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

rucio/db/sqla/models.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");
@@ -15,30 +14,50 @@
 
 import uuid
 from datetime import datetime, timedelta
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
-from sqlalchemy import BigInteger, Boolean, DateTime, Enum, Float, Integer, SmallInteger, String, Text, event, UniqueConstraint, inspect
+from sqlalchemy import BigInteger, Boolean, DateTime, Enum, Float, Integer, SmallInteger, String, Text, UniqueConstraint, event
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.ext.declarative import declared_attr
-from sqlalchemy.orm import mapped_column, object_mapper, relationship, Mapped
-from sqlalchemy.schema import Index, ForeignKeyConstraint, PrimaryKeyConstraint, CheckConstraint, Table
+from sqlalchemy.orm import Mapped, mapped_column, object_mapper, relationship
+from sqlalchemy.schema import CheckConstraint, ForeignKeyConstraint, Index, PrimaryKeyConstraint, Table
 from sqlalchemy.sql import Delete
 from sqlalchemy.types import LargeBinary
 
 from rucio.common import utils
 from rucio.common.schema import get_schema_value
 from rucio.common.types import InternalAccount, InternalScope
-from rucio.db.sqla.constants import (AccountStatus, AccountType, DIDAvailability, DIDType, DIDReEvaluation,
-                                     KeyType, IdentityType, LockState, RuleGrouping, BadFilesStatus,
-                                     RuleState, ReplicaState, RequestState, RequestType, RSEType,
-                                     ScopeStatus, SubscriptionState, RuleNotification, LifetimeExceptionsState,
-                                     BadPFNStatus, TransferLimitDirection)
-from rucio.db.sqla.session import BASE, get_engine
-from rucio.db.sqla.types import GUID, BooleanString, JSON
-from rucio.db.sqla.types import InternalAccountString
-from rucio.db.sqla.types import InternalScopeString
-
+from rucio.db.sqla.constants import (
+    AccountStatus,
+    AccountType,
+    BadFilesStatus,
+    BadPFNStatus,
+    DIDAvailability,
+    DIDReEvaluation,
+    DIDType,
+    IdentityType,
+    KeyType,
+    LifetimeExceptionsState,
+    LockState,
+    ReplicaState,
+    RequestState,
+    RequestType,
+    RSEType,
+    RuleGrouping,
+    RuleNotification,
+    RuleState,
+    ScopeStatus,
+    SubscriptionState,
+    TransferLimitDirection,
+)
+from rucio.db.sqla.session import BASE
+from rucio.db.sqla.types import GUID, JSON, BooleanString, InternalAccountString, InternalScopeString
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine.base import Connection
+    from sqlalchemy.orm import Session
+    from sqlalchemy.sql import Insert, Update
 
 # SQLAlchemy defines the corresponding code behind TYPE_CHECKING
 # https://github.com/sqlalchemy/sqlalchemy/blob/d9acd6223299c118464d30abfa483e26a536239d/lib/sqlalchemy/orm/base.py#L814
@@ -50,24 +69,24 @@ from rucio.db.sqla.types import InternalScopeString
 
 
 @compiles(Boolean, "oracle")
-def compile_binary_oracle(type_, compiler, **kw):
+def compile_binary_oracle(type_, compiler, **kw) -> str:
     return "NUMBER(1)"
 
 
 @event.listens_for(Table, "before_create")
-def _mysql_rename_type(target, connection, **kw):
+def _mysql_rename_type(target: Table, connection: "Connection", **kw) -> None:
     if connection.dialect.name == 'mysql' and target.name == 'quarantined_replicas':
         target.columns.path.type = String(255)
 
 
 @event.listens_for(Table, "before_create")
-def _psql_rename_type(target, connection, **kw):
+def _psql_rename_type(target: Table, connection: "Connection", **kw) -> None:
     if connection.dialect.name == 'postgresql' and target.name == 'account_map':
         target.columns.identity_type.type.name = 'IDENTITIES_TYPE_CHK'
 
 
 @event.listens_for(Table, "before_create")
-def _oracle_json_constraint(target, connection, **kw):
+def _oracle_json_constraint(target: Table, connection: "Connection", **kw) -> None:
     if connection.dialect.name == 'oracle':
         try:
             oracle_version = int(connection.connection.version.split('.')[0])
@@ -76,12 +95,20 @@ def _oracle_json_constraint(target, connection, **kw):
         if oracle_version >= 12:
             if target.name == 'did_meta':
                 target.append_constraint(CheckConstraint('META IS JSON', 'ORACLE_META_JSON_CHK'))
+            if target.name == 'deleted_did_meta':
+                target.append_constraint(CheckConstraint('META IS JSON', 'ORACLE_DELETE_META_JSON_CHK'))
             if target.name == 'virtual_placements':
                 target.append_constraint(CheckConstraint('PLACEMENTS IS JSON', 'ORACLE_PLACEMENTS_JSON_CHK'))
 
 
 @event.listens_for(Engine, "before_execute", retval=True)
-def _add_hint(conn, element, multiparams, params, execution_options):
+def _add_hint(
+    conn: "Connection",
+    element: Union[Delete, "Insert", "Update"],
+    multiparams,
+    params,
+    execution_options
+) -> tuple[Union[Delete, "Insert", "Update"], list, dict]:
     if conn.dialect.name == 'oracle' and isinstance(element, Delete) and element.table.name == 'locks':
         element = element.prefix_with("/*+ INDEX(LOCKS LOCKS_PK) */")
     if conn.dialect.name == 'oracle' and isinstance(element, Delete) and element.table.name == 'replicas':
@@ -96,7 +123,7 @@ def _add_hint(conn, element, multiparams, params, execution_options):
 
 
 @event.listens_for(PrimaryKeyConstraint, "after_parent_attach")
-def _pk_constraint_name(const, table):
+def _pk_constraint_name(const: PrimaryKeyConstraint, table: Table) -> None:
     if table.name.upper() == 'QUARANTINED_REPLICAS_HISTORY':
         const.name = "QRD_REPLICAS_HISTORY_PK"
     else:
@@ -104,7 +131,7 @@ def _pk_constraint_name(const, table):
 
 
 @event.listens_for(ForeignKeyConstraint, "after_parent_attach")
-def _fk_constraint_name(const, table):
+def _fk_constraint_name(const: ForeignKeyConstraint, table: Table) -> None:
     if const.name:
         return
     fk = const.elements[0]
@@ -115,14 +142,14 @@ def _fk_constraint_name(const, table):
 
 
 @event.listens_for(UniqueConstraint, "after_parent_attach")
-def _unique_constraint_name(const, table):
+def _unique_constraint_name(const: UniqueConstraint, table: Table) -> None:
     if const.name:
         return
     const.name = "uq_%s_%s" % (table.name, list(const.columns)[0].name)
 
 
 @event.listens_for(CheckConstraint, "after_parent_attach")
-def _ck_constraint_name(const, table):
+def _ck_constraint_name(const: CheckConstraint, table: Table) -> None:
 
     if const.name is None:
         if 'DELETED' in str(const.sqltext).upper():
@@ -168,7 +195,7 @@ def _ck_constraint_name(const, table):
         const.name = "REQUESTS_HISTORY_STATE_CHK"
 
 
-class ModelBase(object):
+class ModelBase:
     """Base class for Rucio Models"""
     __table_initialized__ = False
 
@@ -205,23 +232,23 @@ class ModelBase(object):
     def updated_at(cls):  # pylint: disable=no-self-argument
         return mapped_column("updated_at", DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
 
-    def save(self, flush=True, session=None):
+    def save(self, flush: bool = True, session: Optional["Session"] = None) -> None:
         """Save this object"""
-        # Sessions created with autoflush=True be default since sqlAlchemy 1.4.
-        # So explicatly calling session.flush is not necessary.
+        # Sessions created with autoflush: bool = True be default since sqlAlchemy 1.4.
+        # So explicitly calling session.flush is not necessary.
         # However, when autogenerated primary keys involved, calling
         # session.flush to get the id from DB.
         session.add(self)
         if flush:
             session.flush()
 
-    def delete(self, flush=True, session=None):
+    def delete(self, flush: bool = True, session: Optional["Session"] = None) -> None:
         """Delete this object"""
         session.delete(self)
         if flush:
             session.flush()
 
-    def update(self, values, flush=True, session=None):
+    def update(self, values: dict[str, Any], flush: bool = True, session: Optional["Session"] = None) -> None:
         """dict.update() behaviour."""
         for k, v in values.items():
             self[k] = v
@@ -279,7 +306,7 @@ class SoftModelBase(ModelBase):
     def deleted_at(cls):  # pylint: disable=no-self-argument
         return mapped_column("deleted_at", DateTime)
 
-    def delete(self, flush=True, session=None):
+    def delete(self, flush: bool = True, session: Optional["Session"] = None) -> None:
         """Delete this object"""
         self.deleted = True
         self.deleted_at = datetime.utcnow()
@@ -462,6 +489,19 @@ class DidMeta(BASE, ModelBase):
                    Index('DID_META_DID_TYPE_IDX', 'did_type'))
 
 
+class DeletedDidMeta(BASE, ModelBase):
+    __tablename__ = 'deleted_did_meta'
+    scope: Mapped[InternalScope] = mapped_column(InternalScopeString(get_schema_value('SCOPE_LENGTH')))
+    name: Mapped[str] = mapped_column(String(get_schema_value('NAME_LENGTH')))
+    did_type: Mapped[Optional[DIDType]] = mapped_column(Enum(DIDType, name='DEL_DID_META_DID_TYPE_CHK',
+                                                             create_constraint=True,
+                                                             values_callable=lambda obj: [e.value for e in obj]))
+    meta: Mapped[Optional[Union[str, dict[str, Any]]]] = mapped_column(JSON())
+    deleted_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
+    _table_args = (PrimaryKeyConstraint('scope', 'name', name='DEL_DID_META_PK'),
+                   Index('DEL_DID_META_DID_TYPE_IDX', 'did_type'))
+
+
 class DeletedDataIdentifier(BASE, ModelBase):
     """Represents a dataset"""
     __tablename__ = 'deleted_dids'
@@ -534,7 +574,7 @@ class UpdatedDID(BASE, ModelBase):
                    Index('UPDATED_DIDS_SCOPERULENAME_IDX', 'scope', 'rule_evaluation_action', 'name'))
 
 
-class BadReplicas(BASE, ModelBase):
+class BadReplica(BASE, ModelBase):
     """Represents the suspicious or bad replicas"""
     __tablename__ = 'bad_replicas'
     scope: Mapped[InternalScope] = mapped_column(InternalScopeString(get_schema_value('SCOPE_LENGTH')))
@@ -558,8 +598,8 @@ class BadReplicas(BASE, ModelBase):
                    Index('BAD_REPLICAS_ACCOUNT_IDX', 'account'))
 
 
-class BadPFNs(BASE, ModelBase):
-    """Represents bad, suspicious or temporary unavailable PFNs which have to be processed and added to BadReplicas Table"""
+class BadPFN(BASE, ModelBase):
+    """Represents bad, suspicious or temporary unavailable PFNs which have to be processed and added to BadReplica Table"""
     __tablename__ = 'bad_pfns'
     path: Mapped[str] = mapped_column(String(2048))  # PREFIX + PFN
     state: Mapped[BadPFNStatus] = mapped_column(Enum(BadPFNStatus, name='BAD_PFNS_STATE_CHK',
@@ -605,8 +645,8 @@ class QuarantinedReplicaHistory(BASE, ModelBase):
     _table_args = ()
 
 
-class DIDKey(BASE, ModelBase):
-    """Represents Data IDentifier property keys"""
+class DIDMetaConventionsKey(BASE, ModelBase):
+    """Represents allowed keys of DID Metadata"""
     __tablename__ = 'did_keys'
     key: Mapped[str] = mapped_column(String(255))
     is_enum: Mapped[bool] = mapped_column(Boolean(name='DID_KEYS_IS_ENUM_CHK', create_constraint=True),
@@ -621,8 +661,8 @@ class DIDKey(BASE, ModelBase):
                    CheckConstraint('is_enum IS NOT NULL', name='DID_KEYS_IS_ENUM_NN'))
 
 
-class DIDKeyValueAssociation(BASE, ModelBase):
-    """Represents Data IDentifier property key/values"""
+class DIDMetaConventionsConstraint(BASE, ModelBase):
+    """Represents a map for constraint values a DID metadata key must follow """
     __tablename__ = 'did_key_map'
     key: Mapped[str] = mapped_column(String(255))
     value: Mapped[str] = mapped_column(String(255))
@@ -854,12 +894,12 @@ class RSEAttrAssociation(BASE, ModelBase):
                    Index('RSE_ATTR_MAP_KEY_VALUE_IDX', 'key', 'value'))
 
 
-class RSEProtocols(BASE, ModelBase):
+class RSEProtocol(BASE, ModelBase):
     """Represents supported protocols of RSEs (Rucio Storage Elements)"""
     __tablename__ = 'rse_protocols'
     rse_id: Mapped[uuid.UUID] = mapped_column(GUID())
     scheme: Mapped[str] = mapped_column(String(255))
-    hostname: Mapped[str] = mapped_column(String(255), server_default='')  # For protocol without host e.g. POSIX on local file systems localhost is assumed as beeing default
+    hostname: Mapped[str] = mapped_column(String(255), server_default='')  # For protocol without host e.g. POSIX on local file systems localhost is assumed as being default
     port: Mapped[int] = mapped_column(Integer, server_default='0')  # like host, for local protocol the port 0 is assumed to be default
     prefix: Mapped[Optional[str]] = mapped_column(String(1024), nullable=True)
     impl: Mapped[str] = mapped_column(String(255), nullable=False)
@@ -1408,30 +1448,36 @@ class SourceHistory(BASE, ModelBase):
                    )
 
 
-# Compatibility code to permit 1.30 to run with a distances table from the 1.29 database schema
-# TODO: remove this code in rucio 1.31
-_distance_column_name = 'distance'
-_engine = get_engine()
-if _engine.dialect.name in ['oracle', 'mysql', 'postgresql']:
-    _insp = inspect(_engine)
-    if _engine.dialect.name in ['oracle', 'postgresql'] or BASE.metadata.schema in _insp.get_schema_names():
-        if 'distances' in _insp.get_table_names(schema=BASE.metadata.schema):
-            if any(c['name'] == 'ranking' for c in _insp.get_columns(table_name='distances', schema=BASE.metadata.schema)):
-                _distance_column_name = 'ranking'
-
-
 class Distance(BASE, ModelBase):
     """Represents distance between rses"""
     __tablename__ = 'distances'
     src_rse_id: Mapped[uuid.UUID] = mapped_column(GUID())
     dest_rse_id: Mapped[uuid.UUID] = mapped_column(GUID())
-    distance: Mapped[Optional[int]] = mapped_column(Integer(), name=_distance_column_name)
+    distance: Mapped[Optional[int]] = mapped_column(Integer())
     _table_args = (PrimaryKeyConstraint('src_rse_id', 'dest_rse_id', name='DISTANCES_PK'),
                    ForeignKeyConstraint(['src_rse_id'], ['rses.id'], name='DISTANCES_SRC_RSES_FK'),
                    ForeignKeyConstraint(['dest_rse_id'], ['rses.id'], name='DISTANCES_DEST_RSES_FK'),
                    Index('DISTANCES_DEST_RSEID_IDX', 'dest_rse_id'))
 
 
+class TransferStats(BASE, ModelBase):
+    """Represents counters for transfer link usage"""
+    __tablename__ = 'transfer_stats'
+    id: Mapped[uuid.UUID] = mapped_column(GUID(), default=utils.generate_uuid)
+    resolution: Mapped[int] = mapped_column(Integer)
+    timestamp: Mapped[datetime] = mapped_column(DateTime)
+    dest_rse_id: Mapped[uuid.UUID] = mapped_column(GUID())
+    src_rse_id: Mapped[uuid.UUID] = mapped_column(GUID())
+    activity: Mapped[Optional[str]] = mapped_column(String(50))
+    files_done: Mapped[int] = mapped_column(BigInteger)
+    bytes_done: Mapped[int] = mapped_column(BigInteger)
+    files_failed: Mapped[int] = mapped_column(BigInteger)
+    _table_args = (PrimaryKeyConstraint('id', name='TRANSFER_STATS_PK'),
+                   ForeignKeyConstraint(['dest_rse_id'], ['rses.id'], name='TRANSFER_STATS_DEST_RSE_FK'),
+                   ForeignKeyConstraint(['src_rse_id'], ['rses.id'], name='TRANSFER_STATS_SRC_RSE_FK'),
+                   Index('TRANSFER_STATS_KEY_IDX', 'resolution', 'timestamp', 'dest_rse_id', 'src_rse_id', 'activity'))
+
+
 class Subscription(BASE, ModelBase):
     """Represents a subscription"""
     __tablename__ = 'subscriptions'
@@ -1478,7 +1524,7 @@ class SubscriptionHistory(BASE, ModelBase):
     retroactive: Mapped[bool] = mapped_column(Boolean(name='SUBS_HISTORY_RETROACTIVE_CHK', create_constraint=True),
                                               default=False)
     expired_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
-    _table_args = (PrimaryKeyConstraint('id', 'updated_at', name='SUBSCRIPTIONS_PK'),)
+    _table_args = (PrimaryKeyConstraint('id', 'updated_at', name='SUBSCRIPTIONS_HISTORY_PK'),)
 
 
 class Token(BASE, ModelBase):
@@ -1575,7 +1621,7 @@ class ConfigHistory(BASE, ModelBase):
     _table_args = ()
 
 
-class Heartbeats(BASE, ModelBase):
+class Heartbeat(BASE, ModelBase):
     """Represents the status and heartbeat of the running daemons and services"""
     __tablename__ = 'heartbeats'
     executable: Mapped[str] = mapped_column(String(64))  # SHA-2
@@ -1600,29 +1646,7 @@ class NamingConvention(BASE, ModelBase):
                    ForeignKeyConstraint(['scope'], ['scopes.scope'], name='NAMING_CONVENTIONS_SCOPE_FK'))
 
 
-class TemporaryDataIdentifier(BASE, ModelBase):
-    """Represents a temporary DID (pre-merged files, etc.)"""
-    __tablename__ = 'tmp_dids'
-    scope: Mapped[InternalScope] = mapped_column(InternalScopeString(get_schema_value('SCOPE_LENGTH')))
-    name: Mapped[str] = mapped_column(String(get_schema_value('NAME_LENGTH')))
-    rse_id: Mapped[Optional[uuid.UUID]] = mapped_column(GUID())
-    path: Mapped[Optional[str]] = mapped_column(String(1024))
-    bytes: Mapped[Optional[int]] = mapped_column(BigInteger)
-    md5: Mapped[Optional[str]] = mapped_column(String(32))
-    adler32: Mapped[Optional[str]] = mapped_column(String(8))
-    expired_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
-    guid: Mapped[Optional[uuid.UUID]] = mapped_column(GUID())
-    events: Mapped[Optional[int]] = mapped_column(BigInteger)
-    task_id: Mapped[Optional[int]] = mapped_column(Integer())
-    panda_id: Mapped[Optional[int]] = mapped_column(Integer())
-    parent_scope: Mapped[Optional[InternalScope]] = mapped_column(InternalScopeString(get_schema_value('SCOPE_LENGTH')))
-    parent_name: Mapped[Optional[str]] = mapped_column(String(get_schema_value('NAME_LENGTH')))
-    offset: Mapped[Optional[int]] = mapped_column(BigInteger)
-    _table_args = (PrimaryKeyConstraint('scope', 'name', name='TMP_DIDS_PK'),
-                   Index('TMP_DIDS_EXPIRED_AT_IDX', 'expired_at'))
-
-
-class LifetimeExceptions(BASE, ModelBase):
+class LifetimeException(BASE, ModelBase):
     """Represents the exceptions to the lifetime model"""
     __tablename__ = 'lifetime_except'
     id: Mapped[uuid.UUID] = mapped_column(GUID(), default=utils.generate_uuid)
@@ -1654,8 +1678,8 @@ class VO(BASE, ModelBase):
     _table_args = (PrimaryKeyConstraint('vo', name='VOS_PK'), )
 
 
-class DidsFollowed(BASE, ModelBase):
-    """Represents the datasets followed by an user"""
+class DidFollowed(BASE, ModelBase):
+    """Represents the datasets followed by a user"""
     __tablename__ = 'dids_followed'
     scope: Mapped[InternalScope] = mapped_column(InternalScopeString(get_schema_value('SCOPE_LENGTH')))
     name: Mapped[str] = mapped_column(String(get_schema_value('NAME_LENGTH')))
@@ -1672,7 +1696,7 @@ class DidsFollowed(BASE, ModelBase):
                    ForeignKeyConstraint(['scope', 'name'], ['dids.scope', 'dids.name'], name='DIDS_FOLLOWED_SCOPE_NAME_FK'))
 
 
-class FollowEvents(BASE, ModelBase):
+class FollowEvent(BASE, ModelBase):
     """Represents the events affecting the datasets which are followed"""
     __tablename__ = 'dids_followed_events'
     scope: Mapped[InternalScope] = mapped_column(InternalScopeString(get_schema_value('SCOPE_LENGTH')))
@@ -1692,143 +1716,25 @@ class FollowEvents(BASE, ModelBase):
                    Index('DIDS_FOLLOWED_EVENTS_ACC_IDX', 'account'))
 
 
-def register_models(engine):
+def register_models(engine: Engine) -> None:
     """
-    Creates database tables for all models with the given engine
+    Creates database tables for all models in the `BASE.metadata` schema with the given engine.
+    Functionally this creates all models, as they all inherit from BASE and exist in the same `BASE.metadata` schema.
+
+    :param engine: engine to register the models with
+    :type engine: sqlalchemy.engine.Engine
+    :returns: None
     """
+    BASE.metadata.create_all(engine)
 
-    models = (Account,
-              AccountAttrAssociation,
-              AccountLimit,
-              AccountGlobalLimit,
-              AccountUsage,
-              AccountUsageHistory,
-              AlembicVersion,
-              BadReplicas,
-              CollectionReplica,
-              Config,
-              ConfigHistory,
-              ConstituentAssociation,
-              ConstituentAssociationHistory,
-              DataIdentifierAssociation,
-              DataIdentifierAssociationHistory,
-              DIDKey,
-              DIDKeyValueAssociation,
-              DataIdentifier,
-              DidMeta,
-              VirtualPlacements,
-              DeletedDataIdentifier,
-              DidsFollowed,
-              FollowEvents,
-              Heartbeats,
-              Identity,
-              IdentityAccountAssociation,
-              LifetimeExceptions,
-              Message,
-              MessageHistory,
-              NamingConvention,
-              OAuthRequest,
-              QuarantinedReplica,
-              QuarantinedReplicaHistory,
-              RSE,
-              RSEAttrAssociation,
-              RSEFileAssociation,
-              RSEFileAssociationHistory,
-              RSELimit,
-              RSEProtocols,
-              RSEQoSAssociation,
-              RSEUsage,
-              RSEUsageHistory,
-              ReplicaLock,
-              ReplicationRule,
-              ReplicationRule,
-              ReplicationRuleHistory,
-              ReplicationRuleHistoryRecent,
-              Request,
-              RequestHistory,
-              TransferHop,
-              Scope,
-              Source,
-              SourceHistory,
-              Subscription,
-              SubscriptionHistory,
-              TemporaryDataIdentifier,
-              Token,
-              UpdatedAccountCounter,
-              UpdatedDID,
-              UpdatedRSECounter,
-              UpdatedCollectionReplica,
-              VO)
-
-    for model in models:
-        model.metadata.create_all(engine)   # pylint: disable=maybe-no-member
-
-
-def unregister_models(engine):
+
+def unregister_models(engine: Engine) -> None:
     """
-    Drops database tables for all models with the given engine
+    Drops database tables for all models in the `BASE.metadata` schema with the given engine.
+    Functionally this drops all models, as they all inherit from BASE and exist in the same `BASE.metadata` schema.
+
+    :param engine: The engine to unregister the models with
+    :type engine: sqlalchemy.engine.Engine
+    :returns: None
     """
-    models = (Account,
-              AccountAttrAssociation,
-              AccountLimit,
-              AccountGlobalLimit,
-              AccountUsage,
-              AccountUsageHistory,
-              AlembicVersion,
-              BadReplicas,
-              CollectionReplica,
-              Config,
-              ConfigHistory,
-              ConstituentAssociation,
-              ConstituentAssociationHistory,
-              DataIdentifierAssociation,
-              DataIdentifierAssociationHistory,
-              DIDKey,
-              DIDKeyValueAssociation,
-              DidMeta,
-              DataIdentifier,
-              DeletedDataIdentifier,
-              DidsFollowed,
-              FollowEvents,
-              Heartbeats,
-              Identity,
-              IdentityAccountAssociation,
-              LifetimeExceptions,
-              Message,
-              MessageHistory,
-              NamingConvention,
-              OAuthRequest,
-              QuarantinedReplica,
-              QuarantinedReplicaHistory,
-              RSE,
-              RSEAttrAssociation,
-              RSEFileAssociation,
-              RSEFileAssociationHistory,
-              RSELimit,
-              RSEProtocols,
-              RSEQoSAssociation,
-              RSEUsage,
-              RSEUsageHistory,
-              ReplicaLock,
-              ReplicationRule,
-              ReplicationRule,
-              ReplicationRuleHistory,
-              ReplicationRuleHistoryRecent,
-              Request,
-              RequestHistory,
-              TransferHop,
-              Scope,
-              Source,
-              SourceHistory,
-              Subscription,
-              SubscriptionHistory,
-              Token,
-              TemporaryDataIdentifier,
-              UpdatedAccountCounter,
-              UpdatedDID,
-              UpdatedRSECounter,
-              UpdatedCollectionReplica,
-              VO)
-
-    for model in models:
-        model.metadata.drop_all(engine)   # pylint: disable=maybe-no-member
+    BASE.metadata.drop_all(engine)

rucio/db/sqla/sautils.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");
@@ -18,19 +17,27 @@ SQLAlchemy utilities
 
 '''
 
+from typing import TYPE_CHECKING, Any, Union
+
 from sqlalchemy.ext.compiler import compiles
-from sqlalchemy.sql.expression import Executable, ClauseElement
+from sqlalchemy.sql.expression import ClauseElement, Executable
+
+if TYPE_CHECKING:
+    from sqlalchemy import Table
+    from sqlalchemy.engine.interfaces import SQLCompiler
+    from sqlalchemy.sql.schema import Column
+    from sqlalchemy.sql.selectable import Select
 
 
 class InsertFromSelect(Executable, ClauseElement):
-    def __init__(self, insert_spec, select):
+    def __init__(self, insert_spec: "Union[Table, list[Column]]", select: "Select") -> None:
         self.insert_spec = insert_spec
         self.select = select
 
 
 @compiles(InsertFromSelect)
-def visit_insert_from_select(element, compiler, **kw):
-    if type(element.insert_spec) == list:
+def visit_insert_from_select(element: InsertFromSelect, compiler: "SQLCompiler", **kw: Any) -> str:
+    if isinstance(element.insert_spec, list):
         columns = []
         for column in element.insert_spec:
             if element.insert_spec[0].table != column.table: