rucio 35.7.0__py3-none-any.whl → 37.0.0rc2__py3-none-any.whl

rucio/core/did_meta_plugins/postgres_meta.py

@@ -16,8 +16,9 @@ import json
 import operator
 from typing import TYPE_CHECKING
 
-import psycopg2
-import psycopg2.extras
+import psycopg
+from psycopg import sql
+from psycopg.rows import dict_row
 
 from rucio.common import config, exception
 from rucio.common.types import InternalScope
@@ -73,17 +74,20 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         self.jsonb_column = table_column_data
 
         self.table = table
-        self.client = psycopg2.connect(
+        self.client = psycopg.connect(
             host=host,
             port=port,
-            database=db,
+            dbname=db,
             user=user,
             password=password)
 
         # set search_path to include database schema by default
         cur = self.client.cursor()
-        statement = "SET search_path TO {};".format(db_schema)
-        cur.execute(statement)
+        cur.execute(
+            sql.SQL("SET search_path TO {}").format(
+                sql.Identifier(db_schema)
+            )
+        )
         cur.close()
 
         if not table_is_managed:                    # not managed by Rucio, so just verify table schema
@@ -97,17 +101,18 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         """
         Try to create a metadata table.
         """
-        table_clauses = (
-            ("id", "bigint", "NOT NULL", "GENERATED ALWAYS AS IDENTITY"),
-            ("vo", "varchar", "NOT NULL"),
-            ("scope", "varchar", "NOT NULL"),
-            ("name", "varchar", "NOT NULL"),
-            ("data", "jsonb", "DEFAULT", "'{}'::jsonb"),
-            ("UNIQUE", "(scope, name)")  # unique scope+name table constraint, required for ON CONFLICT
+        table_clauses = [
+            sql.SQL("id bigint NOT NULL GENERATED ALWAYS AS IDENTITY"),
+            sql.SQL("vo varchar NOT NULL"),
+            sql.SQL("scope varchar NOT NULL"),
+            sql.SQL("name varchar NOT NULL"),
+            sql.SQL("data jsonb DEFAULT '{}'::jsonb"),
+            sql.SQL("UNIQUE (scope, name)")  # unique scope+name table constraint, required for ON CONFLICT
+        ]
+        statement = sql.SQL("CREATE TABLE IF NOT EXISTS {} ({})").format(
+            sql.Identifier(self.table),
+            sql.SQL(', ').join(table_clauses)
         )
-        statement = "CREATE TABLE IF NOT EXISTS {} ({})".format(
-            self.table,
-            ', '.join([' '.join(clause) for clause in table_clauses]))
 
         cur = self.client.cursor()
         cur.execute(statement)
@@ -127,8 +132,11 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         :raises: MetadataSchemaMismatchError
         """
         # Check mandatory columns are of right data type and have the right nullable qualifier.
-        statement = "SELECT column_name, data_type, is_nullable " \
-                    "FROM INFORMATION_SCHEMA.COLUMNS where table_name = '{}';".format(self.table)
+        statement = sql.SQL(
+            "SELECT column_name, data_type, is_nullable FROM INFORMATION_SCHEMA.COLUMNS where table_name = {}").format(
+            sql.Literal(self.table)
+        )
+
         cur = self.client.cursor()
         cur.execute(statement)
         existing_table_columns = cur.fetchall()
@@ -147,14 +155,19 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
                         specification, existing_table_columns))
 
         # Check required table constraints exist.
-        statement = "SELECT con.contype AS constraint_type, " \
-                    "(SELECT array_agg(att.attname) FROM pg_attribute att " \
-                    " INNER JOIN unnest(con.conkey) unnest(conkey) ON unnest.conkey = att.attnum " \
-                    " WHERE att.attrelid = con.conrelid) AS columns " \
-                    "FROM pg_constraint con " \
-                    "INNER JOIN pg_class rel ON rel.oid = con.conrelid " \
-                    "INNER JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace " \
-                    "WHERE rel.relname = '{}';".format(self.table)
+        statement = sql.SQL(
+            "SELECT con.contype AS constraint_type, "  # type: ignore
+            "(SELECT array_agg(att.attname) FROM pg_attribute att "
+            " INNER JOIN unnest(con.conkey) unnest(conkey) ON unnest.conkey = att.attnum "
+            " WHERE att.attrelid = con.conrelid) AS columns "
+            "FROM pg_constraint con "
+            "INNER JOIN pg_class rel ON rel.oid = con.conrelid "
+            "INNER JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace "
+            "WHERE rel.relname = {}"
+        ).format(
+            sql.Literal(self.table)
+        )
+
         cur = self.client.cursor()
         cur.execute(statement)
         existing_table_constraints = cur.fetchall()  # list of (constraint_type, [columns])
@@ -170,9 +183,12 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
                         constraint, len(existing_table_constraints)))
 
     def _drop_metadata_table(self):
-        statement = "DROP TABLE IF EXISTS {};".format(self.table)
         cur = self.client.cursor()
-        cur.execute(statement)
+        cur.execute(
+            sql.SQL("DROP TABLE IF EXISTS {}").format(
+                sql.Identifier(self.table)
+            )
+        )
         cur.close()
         self.client.commit()
 
@@ -185,8 +201,12 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         :param session: The database session in use
         :returns: the metadata for the did
         """
-        statement = "SELECT data from {} ".format(self.table) + \
-                    "WHERE scope='{}' AND name='{}';".format(scope.internal, name)
+        statement = sql.SQL("SELECT data from {} WHERE scope = {} AND name = {}").format(
+            sql.Identifier(self.table),
+            sql.Literal(scope.internal),
+            sql.Literal(name)
+        )
+
         cur = self.client.cursor()
         cur.execute(statement)
         metadata = cur.fetchone()
@@ -221,9 +241,18 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         :param session: The database session in use
         """
         # upsert metadata
-        statement = "INSERT INTO {} (scope, name, vo, data) ".format(self.table) + \
-                    "VALUES ('{}', '{}', '{}', '{}') ".format(scope.external, name, scope.vo, json.dumps(metadata)) + \
-                    "ON CONFLICT (scope, name) DO UPDATE set data = {}.data || EXCLUDED.data;".format(self.table)
+        statement = sql.SQL(
+            "INSERT INTO {} (scope, name, vo, data) VALUES ({}, {}, {}, {}) "  # type: ignore
+            "ON CONFLICT (scope, name) DO UPDATE set data = {}.data || EXCLUDED.data"
+        ).format(
+            sql.Identifier(self.table),
+            sql.Literal(scope.external),
+            sql.Literal(name),
+            sql.Literal(scope.vo),
+            sql.Literal(json.dumps(metadata)),
+            sql.Identifier(self.table)
+        )
+
         cur = self.client.cursor()
         cur.execute(statement)
         cur.close()
@@ -238,8 +267,12 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         :param key: the key to be deleted
         :param session: the database session in use
         """
-        statement = "UPDATE {} ".format(self.table) + \
-                    "SET data = {}.data - '{}';".format(self.table, key)
+        statement = sql.SQL("UPDATE {} SET data = {}.data - {}").format(
+            sql.Identifier(self.table),
+            sql.Identifier(self.table),
+            sql.Literal(key)
+        )
+
         cur = self.client.cursor()
         cur.execute(statement)
         cur.close()
@@ -276,10 +309,13 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
                 "'{}' metadata module does not currently support recursive searches".format(self.plugin_name.lower())
             )
 
-        statement = "SELECT * FROM {} WHERE {} ".format(self.table, postgres_query_str)
-        if limit:
-            statement += "LIMIT {}".format(limit)
-        cur = self.client.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+        statement = sql.SQL("SELECT * FROM {} WHERE {} {}").format(
+            sql.Identifier(self.table),
+            sql.SQL(postgres_query_str),  # type: ignore
+            sql.SQL("LIMIT {}").format(sql.Literal(limit)) if limit else sql.SQL("")
+        )
+
+        cur = self.client.cursor(row_factory=dict_row)
         cur.execute(statement)
         query_result = cur.fetchall()
         cur.close()

rucio/core/identity.py

@@ -21,7 +21,6 @@ from sqlalchemy import select, true
 from sqlalchemy.exc import IntegrityError
 
 from rucio.common import exception
-from rucio.common.types import InternalAccount
 from rucio.core.account import account_exists
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import IdentityType
@@ -33,6 +32,8 @@ if TYPE_CHECKING:
     from sqlalchemy import Row
     from sqlalchemy.orm import Session
 
+    from rucio.common.types import InternalAccount
+
 
 @transactional_session
 def add_identity(identity: str, type_: IdentityType, email: str, password: Optional[str] = None, *, session: "Session") -> None:
@@ -129,7 +130,7 @@ def del_identity(identity: str, type_: IdentityType, *, session: "Session") -> N
 def add_account_identity(
     identity: str,
     type_: IdentityType,
-    account: InternalAccount,
+    account: "InternalAccount",
     email: str,
     default: bool = False,
     password: Optional[str] = None,
@@ -177,7 +178,7 @@ def add_account_identity(
 
 
 @read_session
-def exist_identity_account(identity: str, type_: IdentityType, account: InternalAccount, *, session: "Session") -> bool:
+def exist_identity_account(identity: str, type_: IdentityType, account: "InternalAccount", *, session: "Session") -> bool:
     """
     Check if an identity is mapped to an account.
 
@@ -199,7 +200,7 @@ def exist_identity_account(identity: str, type_: IdentityType, account: Internal
 
 
 @read_session
-def get_default_account(identity: str, type_: IdentityType, oldest_if_none: bool = False, *, session: "Session") -> Optional[InternalAccount]:
+def get_default_account(identity: str, type_: IdentityType, oldest_if_none: bool = False, *, session: "Session") -> Optional["InternalAccount"]:
     """
     Retrieves the default account mapped to an identity.
 
@@ -240,7 +241,7 @@ def get_default_account(identity: str, type_: IdentityType, oldest_if_none: bool
 
 
 @transactional_session
-def del_account_identity(identity: str, type_: IdentityType, account: InternalAccount, *, session: "Session") -> None:
+def del_account_identity(identity: str, type_: IdentityType, account: "InternalAccount", *, session: "Session") -> None:
     """
     Removes a membership association between identity and account.
 

rucio/core/importer.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 from sqlalchemy import select
@@ -30,6 +29,8 @@ from rucio.db.sqla.constants import AccountType, IdentityType, RSEType
 from rucio.db.sqla.session import transactional_session
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from sqlalchemy.orm import Session
 
 
@@ -162,7 +163,7 @@ def import_distances(distances, vo: str = 'def', *, session: "Session") -> None:
 
 
 @transactional_session
-def import_identities(identities: Iterable[dict[str, Any]], account_name: str, old_identities: Iterable[tuple], old_identity_account: tuple[str, str, str], account_email: str, *, session: "Session") -> None:
+def import_identities(identities: 'Iterable[dict[str, Any]]', account_name: str, old_identities: 'Iterable[tuple]', old_identity_account: tuple[str, str, str], account_email: str, *, session: "Session") -> None:
     for identity in identities:
         identity['type'] = IdentityType[identity['type'].upper()]
 
@@ -191,7 +192,7 @@ def import_identities(identities: Iterable[dict[str, Any]], account_name: str, o
 
 
 @transactional_session
-def import_accounts(accounts: Iterable[dict[str, Any]], vo: str = 'def', *, session: "Session") -> None:
+def import_accounts(accounts: 'Iterable[dict[str, Any]]', vo: str = 'def', *, session: "Session") -> None:
     vo_filter = {'account': InternalAccount(account='*', vo=vo)}
     old_accounts = {account['account']: account for account in account_module.list_accounts(filter_=vo_filter, session=session)}
     missing_accounts = [account for account in accounts if account['account'] not in old_accounts]

rucio/core/lifetime_exception.py

@@ -245,8 +245,8 @@ def update_exception(
     :param state:          The states to filter
     :param session:        The database session in use.
     """
-    ALLOWED_STATES = (LifetimeExceptionsState.APPROVED, LifetimeExceptionsState.REJECTED)
-    if state not in ALLOWED_STATES:
+    allowed_states = (LifetimeExceptionsState.APPROVED, LifetimeExceptionsState.REJECTED)
+    if state not in allowed_states:
         raise UnsupportedOperation
 
     query = update(

rucio/core/lock.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import logging
-from collections.abc import Iterable, Iterator
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Optional, Union
 
@@ -32,11 +31,13 @@ from rucio.db.sqla.constants import DIDType, LockState, RuleGrouping, RuleNotifi
 from rucio.db.sqla.session import read_session, stream_session, transactional_session
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
     from sqlalchemy.orm import Session
 
 
 @stream_session
-def get_dataset_locks(scope: InternalScope, name: str, *, session: "Session") -> Iterator[dict[str, Any]]:
+def get_dataset_locks(scope: InternalScope, name: str, *, session: "Session") -> "Iterator[dict[str, Any]]":
     """
     Get the dataset locks of a dataset
 
@@ -75,7 +76,7 @@ def get_dataset_locks(scope: InternalScope, name: str, *, session: "Session") ->
 
 
 @stream_session
-def get_dataset_locks_bulk(dids: Iterable[dict[str, Any]], *, session: "Session") -> Iterator[dict[str, Any]]:
+def get_dataset_locks_bulk(dids: "Iterable[dict[str, Any]]", *, session: "Session") -> "Iterator[dict[str, Any]]":
     """
     Get the dataset locks of a list of datasets or containers, recursively
 
@@ -111,7 +112,7 @@ def get_dataset_locks_bulk(dids: Iterable[dict[str, Any]], *, session: "Session"
 
 
 @stream_session
-def get_dataset_locks_by_rse_id(rse_id: str, *, session: "Session") -> Iterator[dict[str, Any]]:
+def get_dataset_locks_by_rse_id(rse_id: str, *, session: "Session") -> "Iterator[dict[str, Any]]":
     """
     Get the dataset locks of an RSE.
 
@@ -151,7 +152,7 @@ def get_dataset_locks_by_rse_id(rse_id: str, *, session: "Session") -> Iterator[
 
 
 @read_session
-def get_replica_locks(scope: InternalScope, name: str, nowait: bool = False, restrict_rses: Optional[Iterable[str]] = None, *, session: "Session") -> list[models.ReplicaLock]:
+def get_replica_locks(scope: InternalScope, name: str, nowait: bool = False, restrict_rses: Optional["Iterable[str]"] = None, *, session: "Session") -> list[models.ReplicaLock]:
     """
     Get the active replica locks for a file
 
@@ -244,7 +245,7 @@ def get_replica_locks_for_rule_id_per_rse(rule_id: str, *, session: "Session") -
 
 
 @read_session
-def get_files_and_replica_locks_of_dataset(scope: InternalScope, name: str, nowait: bool = False, restrict_rses: Optional[Iterable[str]] = None, only_stuck: bool = False,
+def get_files_and_replica_locks_of_dataset(scope: InternalScope, name: str, nowait: bool = False, restrict_rses: Optional["Iterable[str]"] = None, only_stuck: bool = False,
                                            total_threads: Optional[int] = None, thread_id: Optional[int] = None,
                                            *, session: "Session") -> dict[tuple[InternalScope, str], Union[models.ReplicaLock, list[models.ReplicaLock]]]:
     """
@@ -527,7 +528,7 @@ def failed_transfer(scope: InternalScope, name: str, rse_id: str, error_message:
 
 
 @transactional_session
-def touch_dataset_locks(dataset_locks: Iterable[dict[str, Any]], *, session: "Session") -> bool:
+def touch_dataset_locks(dataset_locks: "Iterable[dict[str, Any]]", *, session: "Session") -> bool:
     """
     Update the accessed_at timestamp of the given dataset locks + eol_at.
 

rucio/core/message.py

@@ -101,6 +101,7 @@ def retrieve_messages(bulk: int = 1000,
                       event_type: "Optional[str]" = None,
                       lock: bool = False,
                       old_mode: bool = True,
+                      service_filter: "Optional[str]" = None,
                       *, session: "Session") -> "MessagesListType":
     """
     Retrieve up to $bulk messages.
@@ -112,6 +113,7 @@ def retrieve_messages(bulk: int = 1000,
     :param lock: Select exclusively some rows.
     :param old_mode: If True, doesn't return email if event_type is None.
     :param session: The database session to use.
+    :param service_filter: When a service is supplied this queries the database for messages for that service.
 
     :returns messages: List of dictionaries {id, created_at, event_type, payload, services}
     """
@@ -123,6 +125,10 @@ def retrieve_messages(bulk: int = 1000,
             Message.created_at
         )
         stmt_subquery = filter_thread_work(session=session, query=stmt_subquery, total_threads=total_threads, thread_id=thread)
+        if service_filter:
+            stmt_subquery = stmt_subquery.where(
+                Message.services == service_filter
+            )
         if event_type:
             stmt_subquery = stmt_subquery.where(
                 Message.event_type == event_type

rucio/core/monitor.py

@@ -21,7 +21,6 @@ import logging
 import os
 import string
 from abc import abstractmethod
-from collections.abc import Callable, Iterable, Sequence
 from datetime import datetime, timedelta
 from functools import wraps
 from pathlib import Path
@@ -37,6 +36,8 @@ from rucio.common.stopwatch import Stopwatch
 from rucio.common.utils import retrying
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
     from rucio.common.types import LoggerFunction
 
 _T = TypeVar('_T')
@@ -61,15 +62,15 @@ class MultiprocessMutexValue(values.MultiProcessValue()):
         super().__init__(*args, **kwargs)
         self._lock = Lock()
 
-    def inc(self, amount):
+    def inc(self, amount: float) -> None:
         with self._lock:
             return super().inc(amount)
 
-    def set(self, value):
+    def set(self, value: float) -> None:
         with self._lock:
             return super().set(value)
 
-    def get(self):
+    def get(self) -> float:
         with self._lock:
             return super().get()
 
@@ -163,7 +164,7 @@ class _MultiMetric:
             statsd: str,
             prom: Optional[Union[str, Counter, Gauge, Histogram]] = None,
             documentation: Optional[str] = None,
-            labelnames: Optional[Sequence[str]] = None,
+            labelnames: Optional['Sequence[str]'] = None,
             registry: Optional[CollectorRegistry] = None
     ):
         """
@@ -191,7 +192,7 @@ class _MultiMetric:
         self._labelnames = labelnames
 
     @abstractmethod
-    def init_prometheus_metric(self, name: str, documentation: Optional[str], labelnames: Sequence[str] = ()):
+    def init_prometheus_metric(self, name: str, documentation: Optional[str], labelnames: 'Sequence[str]' = ()):
         pass
 
     def labels(self: _M, **labelkwargs) -> _M:
@@ -199,7 +200,7 @@ class _MultiMetric:
             return self
 
         return self.__class__(
-            prom=self._prom.labels(**labelkwargs),
+            prom=self._prom.labels(**labelkwargs),  # type: ignore
             statsd=self._statsd.format(**labelkwargs),
             documentation=self._documentation,
             labelnames=self._labelnames,
@@ -209,24 +210,24 @@ class _MultiMetric:
 
 class _MultiCounter(_MultiMetric):
 
-    def inc(self, delta=1):
+    def inc(self, delta: int = 1) -> None:
         delta = abs(delta)
-        self._prom.inc(delta)
+        self._prom.inc(delta)  # type: ignore
         if STATSD_CLIENT:
             STATSD_CLIENT.incr(self._statsd, delta)
 
-    def init_prometheus_metric(self, name: str, documentation: str, labelnames: Sequence[str] = ()) -> Counter:
+    def init_prometheus_metric(self, name: str, documentation: str, labelnames: 'Sequence[str]' = ()) -> Counter:
         return Counter(name, documentation, labelnames=labelnames, registry=self._registry)
 
 
 class _MultiGauge(_MultiMetric):
 
-    def set(self, value):
-        self._prom.set(value)
+    def set(self, value) -> None:
+        self._prom.set(value)  # type: ignore
         if STATSD_CLIENT:
             STATSD_CLIENT.gauge(self._statsd, value)
 
-    def init_prometheus_metric(self, name: str, documentation: str, labelnames: Sequence[str] = ()) -> Gauge:
+    def init_prometheus_metric(self, name: str, documentation: str, labelnames: 'Sequence[str]' = ()) -> Gauge:
         return Gauge(name, documentation, labelnames=labelnames, registry=self._registry)
 
 
@@ -237,20 +238,20 @@ class _MultiTiming(_MultiMetric):
             statsd: str,
             prom: Optional[str] = None,
             documentation: Optional[str] = None,
-            labelnames: Optional[Sequence[str]] = None,
+            labelnames: Optional['Sequence[str]'] = None,
             registry: Optional[CollectorRegistry] = None,
-            buckets: Iterable[float] = _HISTOGRAM_DEFAULT_BUCKETS,
+            buckets: 'Iterable[float]' = _HISTOGRAM_DEFAULT_BUCKETS,
     ) -> None:
         self._stopwatch = None
         self._histogram_buckets = tuple(buckets)
         super().__init__(statsd, prom, documentation, labelnames, registry)
 
-    def observe(self, value: float):
-        self._prom.observe(value)
+    def observe(self, value: float) -> None:
+        self._prom.observe(value)  # type: ignore
         if STATSD_CLIENT:
             STATSD_CLIENT.timing(self._statsd, value * 1000)
 
-    def init_prometheus_metric(self, name: str, documentation: str, labelnames: Sequence[str] = ()) -> Histogram:
+    def init_prometheus_metric(self, name: str, documentation: str, labelnames: 'Sequence[str]' = ()) -> Histogram:
         return Histogram(name, documentation, labelnames=labelnames, registry=self._registry, buckets=self._histogram_buckets)
 
     def __enter__(self):
@@ -265,9 +266,9 @@ class _MultiTiming(_MultiMetric):
 
 def _fetch_or_create_metric(
         name: str,
-        labelnames: Optional[Sequence[str]],
+        labelnames: Optional['Sequence[str]'],
         container: dict[str, _T],
-        factory: Callable[[str, Optional[Sequence[str]]], _T]
+        factory: 'Callable[[str, Optional[Sequence[str]]], _T]'
 ) -> "_T":
     metric = container.get(name)
     if not metric:
@@ -280,7 +281,7 @@ def _fetch_or_create_metric(
 
 def _fetch_or_create_counter(
         name: str,
-        labelnames: Optional[Sequence[str]] = None,
+        labelnames: Optional['Sequence[str]'] = None,
         documentation: Optional[str] = None,
         registry: Optional[CollectorRegistry] = None,
 ) -> _MultiCounter:
@@ -295,7 +296,7 @@ def _fetch_or_create_counter(
 
 def _fetch_or_create_gauge(
         name: str,
-        labelnames: Optional[Sequence[str]] = None,
+        labelnames: Optional['Sequence[str]'] = None,
         documentation: Optional[str] = None,
         registry: Optional[CollectorRegistry] = None,
 ) -> _MultiGauge:
@@ -310,10 +311,10 @@ def _fetch_or_create_gauge(
 
 def _fetch_or_create_timer(
         name: str,
-        labelnames: Optional[Sequence[str]] = None,
+        labelnames: Optional['Sequence[str]'] = None,
         documentation: Optional[str] = None,
         registry: Optional[CollectorRegistry] = None,
-        buckets: Iterable[float] = _HISTOGRAM_DEFAULT_BUCKETS
+        buckets: 'Iterable[float]' = _HISTOGRAM_DEFAULT_BUCKETS
 ) -> _MultiTiming:
     return _fetch_or_create_metric(
         name=name,
@@ -332,7 +333,7 @@ class MetricManager:
     """
 
     def __init__(self, prefix: Optional[str] = None, module: Optional[str] = None,
-                 registry: Optional[CollectorRegistry] = None, push_gateways: Optional[Sequence[str]] = None):
+                 registry: Optional[CollectorRegistry] = None, push_gateways: Optional['Sequence[str]'] = None):
         if prefix:
             self.prefix = prefix
         elif module:
@@ -354,7 +355,7 @@ class MetricManager:
             self,
             name: str,
             *,
-            labelnames: Optional[Sequence[str]] = None,
+            labelnames: Optional['Sequence[str]'] = None,
             documentation: Optional[str] = None,
     ) -> _MultiCounter:
         """
@@ -370,7 +371,7 @@ class MetricManager:
             self,
             name: str,
             *,
-            labelnames: Optional[Sequence[str]] = None,
+            labelnames: Optional['Sequence[str]'] = None,
             documentation: Optional[str] = None,
     ) -> _MultiGauge:
         """
@@ -386,9 +387,9 @@ class MetricManager:
             self,
             name: str,
             *,
-            labelnames: Optional[Sequence[str]] = None,
+            labelnames: Optional['Sequence[str]'] = None,
             documentation: Optional[str] = None,
-            buckets: Iterable[float] = _HISTOGRAM_DEFAULT_BUCKETS
+            buckets: 'Iterable[float]' = _HISTOGRAM_DEFAULT_BUCKETS
     ) -> _MultiTiming:
         """
         Log a time measurement.

rucio/core/naming_convention.py

@@ -20,7 +20,7 @@ from dogpile.cache.api import NO_VALUE
 from sqlalchemy import and_, delete, select
 from sqlalchemy.exc import IntegrityError
 
-from rucio.common.cache import make_region_memcached
+from rucio.common.cache import MemcacheRegion
 from rucio.common.exception import Duplicate, InvalidObject, RucioException
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import KeyType
@@ -37,7 +37,7 @@ if TYPE_CHECKING:
         scope: InternalScope
         regexp: str
 
-REGION = make_region_memcached(expiration_time=900)
+REGION = MemcacheRegion(expiration_time=900)
 
 
 @transactional_session

rucio/core/nongrid_trace.py

@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING, Any, Union, overload
 
 import stomp
 
-from rucio.common.config import config_get, config_get_int
+from rucio.common.config import config_get, config_get_int, config_get_list
 from rucio.common.logging import rucio_log_formatter
 from rucio.core.monitor import MetricManager
 
@@ -58,7 +58,7 @@ ROTATING_LOGGER.addHandler(ROTATING_HANDLER)
 
 BROKERS_ALIAS, BROKERS_RESOLVED = [], []
 try:
-    BROKERS_ALIAS = [b.strip() for b in config_get('nongrid-trace', 'brokers').split(',')]
+    BROKERS_ALIAS = config_get_list('nongrid-trace', 'brokers')
 except:
     raise Exception('Could not load brokers from configuration')