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

rucio/rse/translation.py

@@ -0,0 +1,260 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import hashlib
+import importlib
+import logging
+from configparser import NoOptionError, NoSectionError
+from typing import TYPE_CHECKING, Any, Optional
+
+from rucio.common import config
+from rucio.common.constants import RseAttr
+from rucio.common.exception import ConfigNotFound
+from rucio.common.plugins import PolicyPackageAlgorithms
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from rucio.common.types import RSESettingsDict
+
+
+class RSEDeterministicScopeTranslation(PolicyPackageAlgorithms):
+    """
+        Translates a pfn dictionary into a scope and name
+    """
+
+    _algorithm_type = "pfn2lfn"
+
+    def __init__(self, vo: str = 'def'):
+        super().__init__()
+
+        logger = logging.getLogger(__name__)
+
+        try:
+            algorithm_name = config.config_get('policy', self._algorithm_type)
+        except (ConfigNotFound, NoOptionError, NoSectionError, RuntimeError):
+            logger.debug("PFN2LFN: no algorithm specified in the config.")
+            if super()._supports(self._algorithm_type, vo):
+                algorithm_name = vo
+            else:
+                algorithm_name = "def"
+            logger.debug("PFN2LFN: Falling back to %s algorithm.", 'default' if algorithm_name == 'def' else algorithm_name)
+
+        self.parser = self.get_parser(algorithm_name)
+
+    @classmethod
+    def _module_init_(cls) -> None:
+        """
+        Registers the included scope extraction algorithms
+        """
+        cls.register(cls._default, "def")
+
+    @classmethod
+    def get_parser(cls, algorithm_name: str) -> 'Callable[..., Any]':
+        return super()._get_one_algorithm(cls._algorithm_type, algorithm_name)
+
+    @classmethod
+    def register(
+        cls,
+        pfn2lfn_callable: 'Callable',
+        name: Optional[str] = None
+    ) -> None:
+        """
+        Provided a callable function, register it as one of the valid PFN2LFN algorithms.
+
+
+        :param pfn2lfn_callable: Callable function to use.
+        :param name: Algorithm name used for registration.
+        """
+        if name is None:
+            name = pfn2lfn_callable.__name__
+        algorithm_dict = {name: pfn2lfn_callable}
+        super()._register(cls._algorithm_type, algorithm_dict)
+
+    @staticmethod
+    def _default(parsed_pfn: 'Mapping[str, str]') -> tuple[str, str]:
+        """ Translate pfn to name/scope pair
+
+        :param parsed_pfn: dictionary representing pfn containing:
+            - path: str,
+            - name: str
+        :return: tuple containing name, scope
+        """
+        path = parsed_pfn['path']
+        scope = path.lstrip('/').split('/')[0]
+        name = parsed_pfn['name']
+        return name, scope
+
+
+RSEDeterministicScopeTranslation._module_init_()  # pylint: disable=protected-access
+
+
+class RSEDeterministicTranslation(PolicyPackageAlgorithms):
+    """
+    Execute the logic for translating a LFN to a path.
+    """
+
+    _DEFAULT_LFN2PFN = "hash"
+    _algorithm_type = "lfn2pfn"
+
+    def __init__(
+            self,
+            rse: Optional[str] = None,
+            rse_attributes: Optional["RSESettingsDict"] = None,
+            protocol_attributes: Optional[dict[str, Any]] = None
+    ):
+        """
+        Initialize a translator object from the RSE, its attributes, and the protocol-specific
+        attributes.
+
+        :param rse: Name of RSE for this translation.
+        :param rse_attributes: A dictionary of RSE-specific attributes for use in the translation.
+        :param protocol_attributes: A dictionary of RSE/protocol-specific attributes.
+        """
+        super().__init__()
+        self.rse = rse
+        self.rse_attributes = rse_attributes if rse_attributes else {}
+        self.protocol_attributes = protocol_attributes if protocol_attributes else {}
+
+    @classmethod
+    def supports(
+        cls,
+        name: str
+    ) -> bool:
+        """
+        Check to see if a specific algorithm is supported.
+
+        :param name: Name of the deterministic algorithm.
+        :returns: True if `name` is an algorithm supported by the translator class, False otherwise
+        """
+        return super()._supports(cls._algorithm_type, name)
+
+    @classmethod
+    def register(
+        cls,
+        lfn2pfn_callable: 'Callable',
+        name: Optional[str] = None
+    ) -> None:
+        """
+        Provided a callable function, register it as one of the valid LFN2PFN algorithms.
+
+        The callable will receive five arguments:
+         - scope: Scope of the LFN.
+         - name: LFN's path name
+         - rse: RSE name the translation is being done for.
+         - rse_attributes: Attributes of the RSE.
+         - protocol_attributes: Attributes of the RSE's protocol
+        The return value should be the last part of the PFN - it will be appended to the
+        rest of the URL.
+
+        :param lfn2pfn_callable: Callable function to use for generating paths.
+        :param name: Algorithm name used for registration.  If None, then `lfn2pfn_callable.__name__` is used.
+        """
+        if name is None:
+            name = lfn2pfn_callable.__name__
+        algorithm_dict = {name: lfn2pfn_callable}
+        super()._register(cls._algorithm_type, algorithm_dict)
+
+    @staticmethod
+    def __hash(
+        scope: str,
+        name: str,
+        rse: str,
+        rse_attrs: dict[str, Any],
+        protocol_attrs: dict[str, Any]
+    ) -> str:
+        """
+        Given a LFN, turn it into a sub-directory structure using a hash function.
+
+        This takes the MD5 of the LFN and uses the first four characters as a subdirectory
+        name.
+
+        :param scope: Scope of the LFN.
+        :param name: File name of the LFN.
+        :param rse: RSE for PFN (ignored)
+        :param rse_attrs: RSE attributes for PFN (ignored)
+        :param protocol_attrs: RSE protocol attributes for PFN (ignored)
+        :returns: Path for use in the PFN generation.
+        """
+        del rse
+        del rse_attrs
+        del protocol_attrs
+        hstr = hashlib.md5(('%s:%s' % (scope, name)).encode('utf-8')).hexdigest()
+        if scope.startswith('user') or scope.startswith('group'):
+            scope = scope.replace('.', '/')
+        return '%s/%s/%s/%s' % (scope, hstr[0:2], hstr[2:4], name)
+
+    @staticmethod
+    def __identity(
+        scope: str,
+        name: str,
+        rse: str,
+        rse_attrs: dict[str, Any],
+        protocol_attrs: dict[str, Any]
+    ) -> str:
+        """
+        Given a LFN, convert it directly to a path using the mapping:
+
+            scope:path -> scope/path
+
+        :param scope: Scope of the LFN.
+        :param name: File name of the LFN.
+        :param rse: RSE for PFN (ignored)
+        :param rse_attrs: RSE attributes for PFN (ignored)
+        :param protocol_attrs: RSE protocol attributes for PFN (ignored)
+        :returns: Path for use in the PFN generation.
+        """
+        del rse
+        del rse_attrs
+        del protocol_attrs
+        if scope.startswith('user') or scope.startswith('group'):
+            scope = scope.replace('.', '/')
+        return '%s/%s' % (scope, name)
+
+    @classmethod
+    def _module_init_(cls) -> None:
+        """
+        Initialize the class object on first module load.
+        """
+        cls.register(cls.__hash, "hash")
+        cls.register(cls.__identity, "identity")
+        policy_module = None
+        try:
+            policy_module = config.config_get('policy', 'lfn2pfn_module')
+        except (ConfigNotFound, NoOptionError, NoSectionError):
+            pass
+        if policy_module:
+            importlib.import_module(policy_module)
+
+        cls._DEFAULT_LFN2PFN = config.get_lfn2pfn_algorithm_default()
+
+    def path(
+            self,
+            scope: str,
+            name: str
+    ) -> str:
+        """ Transforms the logical file name into a PFN's path.
+
+            :param lfn: filename
+            :param scope: scope
+
+            :returns: RSE specific URI of the physical file
+        """
+        algorithm = self.rse_attributes.get(RseAttr.LFN2PFN_ALGORITHM, 'default')
+        if algorithm == 'default':
+            algorithm = RSEDeterministicTranslation._DEFAULT_LFN2PFN
+        algorithm_callable = super()._get_one_algorithm(RSEDeterministicTranslation._algorithm_type, algorithm)
+        return algorithm_callable(scope, name, self.rse, self.rse_attributes, self.protocol_attributes)
+
+
+RSEDeterministicTranslation._module_init_()  # pylint: disable=protected-access

rucio/tests/common.py

@@ -18,12 +18,11 @@ import json
 import os
 import tempfile
 from collections import namedtuple
-from collections.abc import Callable, Iterable
 from functools import wraps
 from os import rename
 from random import choice, choices
 from string import ascii_letters, ascii_uppercase, digits
-from typing import Any, Optional
+from typing import IO, TYPE_CHECKING, Any, Literal, Optional
 
 import pytest
 import requests
@@ -32,6 +31,12 @@ from rucio.common.config import config_get, config_get_bool, get_config_dirs
 from rucio.common.utils import execute
 from rucio.common.utils import generate_uuid as uuid
 
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Iterator
+    from types import ModuleType
+
+    from werkzeug.test import TestResponse
+
 skip_rse_tests_with_accounts = pytest.mark.skipif(not any(os.path.exists(os.path.join(d, 'rse-accounts.cfg')) for d in get_config_dirs()),
                                                   reason='fails if no rse-accounts.cfg found')
 skiplimitedsql = pytest.mark.skipif('RDBMS' in os.environ and os.environ['RDBMS'] == 'sqlite',
@@ -40,6 +45,8 @@ skip_multivo = pytest.mark.skipif('SUITE' in os.environ and os.environ['SUITE']
                                   reason="does not work for multiVO")
 skip_non_belleii = pytest.mark.skipif(not ('POLICY' in os.environ and os.environ['POLICY'] == 'belleii'),
                                       reason="specific belleii tests")
+skip_outside_gh_actions = pytest.mark.skipif(os.getenv("GITHUB_ACTIONS") != "true",
+                                             reason="Skipping tests outside GitHub Actions")
 
 
 def is_influxdb_available() -> bool:
@@ -167,10 +174,13 @@ def make_temp_file(dir_: str, data: str) -> str:
 
 
 @contextlib.contextmanager
-def mock_open(module, file_like_object):
+def mock_open(module: "ModuleType", file_like_object: IO):
     call_info = {}
 
-    def mocked_open(filename, mode='r'):
+    def mocked_open(
+            filename: str,
+            mode: str = 'r'
+    ) -> contextlib.closing[IO]:
         call_info['filename'] = filename
         call_info['mode'] = mode
         file_like_object.close = lambda: None
@@ -184,7 +194,7 @@ def mock_open(module, file_like_object):
         delattr(module, 'open')
 
 
-def print_response(rest_response):
+def print_response(rest_response: "TestResponse") -> None:
     print('Status:', rest_response.status)
     print()
     nohdrs = True
@@ -202,31 +212,31 @@ def print_response(rest_response):
     print(text if text else '<no content>')
 
 
-def headers(*iterables: Iterable):
+def headers(*iterables: "Iterable") -> list[itertools.chain]:
     return list(itertools.chain(*iterables))
 
 
-def loginhdr(account: str, username: str, password: str):
+def loginhdr(account: str, username: str, password: str) -> "Iterator[tuple[Literal['X-Rucio-Account', 'X-Rucio-Username', 'X-Rucio-Password'], str]]":
     yield 'X-Rucio-Account', str(account)
     yield 'X-Rucio-Username', str(username)
     yield 'X-Rucio-Password', str(password)
 
 
-def auth(token):
+def auth(token) -> "Iterator[tuple[Literal['X-Rucio-Auth-Token'], str]]":
     yield 'X-Rucio-Auth-Token', str(token)
 
 
-def vohdr(vo: str):
+def vohdr(vo: str) -> "Iterator[tuple[Literal['X-Rucio-VO'], str]]":
     if vo:
         yield 'X-Rucio-VO', str(vo)
 
 
-def hdrdict(dictionary: dict):
+def hdrdict(dictionary: dict[str, Any]) -> "Iterator[tuple[str, str]]":
     for key in dictionary:
         yield str(key), str(dictionary[key])
 
 
-def accept(mimetype):
+def accept(mimetype: "Mime") -> "Iterator[tuple[Literal['Accept'], Mime]]":
     yield 'Accept', mimetype
 
 
@@ -244,9 +254,9 @@ def load_test_conf_file(file_name: str) -> dict[str, Any]:
         return json.load(f)
 
 
-def remove_config(func: Callable) -> Callable:
+def remove_config(func: "Callable") -> "Callable":
     @wraps(func)
-    def wrapper(*args, **kwargs):
+    def wrapper(*args, **kwargs) -> None:
         for configfile in get_config_dirs():
             # Rename the config to <config>.tmp
             try:

rucio/tests/common_server.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import copy
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy import and_, delete, exists, select
-from sqlalchemy.orm import aliased
+from sqlalchemy.orm import Session, aliased
 
 from rucio.core import config as core_config
 from rucio.core.vo import map_vo
@@ -23,15 +24,26 @@ from rucio.db.sqla.session import get_session, transactional_session
 
 from .common import get_long_vo
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sqlalchemy.sql.elements import ColumnElement
+    from sqlalchemy.sql.schema import ForeignKeyConstraint
+    from sqlalchemy.sql.selectable import FromClause
+
 # Functions containing server-only includes that can't be included in client tests
 # For each table, get the foreign key constraints from all other tables towards this table.
-INBOUND_FOREIGN_KEYS = {}
+INBOUND_FOREIGN_KEYS: "dict[FromClause, set[ForeignKeyConstraint]]" = {}
 for __table in models.BASE.metadata.tables.values():
     for __fk in __table.foreign_key_constraints:
         INBOUND_FOREIGN_KEYS.setdefault(__fk.referred_table, set()).add(__fk)
 
 
-def _dependency_paths(stack, nb_times_in_stack, cur_table):
+def _dependency_paths(
+        stack: list["ForeignKeyConstraint"],
+        nb_times_in_stack: dict["FromClause", int],
+        cur_table: "FromClause"
+) -> "Iterator":
     """
     Generates lists of foreign keys: paths starting at cur_table and
     navigating the table graph via foreign key constraints.
@@ -61,7 +73,12 @@ def _dependency_paths(stack, nb_times_in_stack, cur_table):
 
 
 @transactional_session
-def cleanup_db_deps(model, select_rows_stmt, *, session=None):
+def cleanup_db_deps(
+    model: models.BASE,
+    select_rows_stmt: "ColumnElement",
+    *,
+    session: Optional["Session"] = None
+) -> None:
     """
     Removes rows which have foreign key constraints pointing to rows
     selected by `select_rows_stmt` in `model`. The deletion is transitive.
@@ -81,10 +98,10 @@ def cleanup_db_deps(model, select_rows_stmt, *, session=None):
             else:
                 seen_tables.add(current_table)
 
-            filters.append(and_(current_table.columns.get(e.parent.name) == referred_table.columns.get(e.column.name) for e in fk.elements))
+            filters.append(and_(current_table.columns.get(e.parent.name) == referred_table.columns.get(e.column.name) for e in fk.elements))  # type: ignore
             referred_table = current_table
 
-        if session.bind.dialect.name == 'mysql':
+        if session.bind.dialect.name == 'mysql':  # type: ignore (bind could be None)
             stmt = delete(
                 current_table
             ).where(
@@ -111,10 +128,10 @@ def cleanup_db_deps(model, select_rows_stmt, *, session=None):
             synchronize_session=False
         )
 
-        session.execute(stmt)
+        session.execute(stmt)  # type: ignore (Session could be None)
 
 
-def reset_config_table():
+def reset_config_table() -> None:
     """ Clear the config table and install any default entries needed for the tests.
     """
     db_session = get_session()
@@ -124,7 +141,7 @@ def reset_config_table():
     core_config.set("vo-map", "testvo2", "ts2")
 
 
-def get_vo():
+def get_vo() -> str:
     """ Gets the current short/mapped VO name for testing.
     Maps the vo name to the short name, if configured.
     :returns: VO name string.

rucio/transfertool/bittorrent.py

@@ -14,26 +14,27 @@
 
 import base64
 import logging
-from collections.abc import Mapping, Sequence
 from os import path
 from typing import TYPE_CHECKING, Any, Optional
 
-from rucio.common import types
+from rucio.common.bittorrent import construct_torrent
 from rucio.common.config import config_get
 from rucio.common.constants import RseAttr
 from rucio.common.extra import import_extras
-from rucio.common.utils import construct_torrent
 from rucio.core.did_meta_plugins import get_metadata
 from rucio.transfertool.transfertool import TransferStatusReport, Transfertool, TransferToolBuilder
 
-from .bittorrent_driver import BittorrentDriver
-
 if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from rucio.common import types
     from rucio.core.request import DirectTransfer
     from rucio.core.rse import RseData
 
+    from .bittorrent_driver import BittorrentDriver
+
 DRIVER_NAME_RSE_ATTRIBUTE = 'bittorrent_driver'
-DRIVER_CLASSES_BY_NAME: dict[str, type[BittorrentDriver]] = {}
+DRIVER_CLASSES_BY_NAME: dict[str, type['BittorrentDriver']] = {}
 
 EXTRA_MODULES = import_extras(['qbittorrentapi'])
 
@@ -51,7 +52,7 @@ class BittorrentTransfertool(Transfertool):
 
     required_rse_attrs = (DRIVER_NAME_RSE_ATTRIBUTE, )
 
-    def __init__(self, external_host: str, logger: types.LoggerFunction = logging.log) -> None:
+    def __init__(self, external_host: str, logger: 'types.LoggerFunction' = logging.log) -> None:
         super().__init__(external_host=external_host, logger=logger)
 
         self._drivers_by_rse_id = {}
@@ -60,7 +61,7 @@ class BittorrentTransfertool(Transfertool):
         self.tracker = config_get('transfers', 'bittorrent_tracker_addr', raise_exception=False, default=None)
 
     @classmethod
-    def _pick_management_api_driver_cls(cls: "type[BittorrentTransfertool]", rse: "RseData") -> Optional[type[BittorrentDriver]]:
+    def _pick_management_api_driver_cls(cls: "type[BittorrentTransfertool]", rse: "RseData") -> Optional[type['BittorrentDriver']]:
         driver_cls = DRIVER_CLASSES_BY_NAME.get(rse.attributes.get(DRIVER_NAME_RSE_ATTRIBUTE, ''))
         if driver_cls is None:
             return None
@@ -68,7 +69,7 @@ class BittorrentTransfertool(Transfertool):
             return None
         return driver_cls
 
-    def _driver_for_rse(self, rse: "RseData") -> Optional[BittorrentDriver]:
+    def _driver_for_rse(self, rse: "RseData") -> Optional['BittorrentDriver']:
         driver = self._drivers_by_rse_id.get(rse.id)
         if driver:
             return driver
@@ -93,7 +94,7 @@ class BittorrentTransfertool(Transfertool):
     def submission_builder_for_path(
             cls: "type[BittorrentTransfertool]",
             transfer_path: "list[DirectTransfer]",
-            logger: types.LoggerFunction = logging.log
+            logger: 'types.LoggerFunction' = logging.log
     ) -> "tuple[list[DirectTransfer], Optional[TransferToolBuilder]]":
         hop = transfer_path[0]
         if hop.rws.byte_count == 0:
@@ -121,7 +122,7 @@ class BittorrentTransfertool(Transfertool):
         return [{'transfers': transfer_path, 'job_params': {}} for transfer_path in transfer_paths]
 
     @staticmethod
-    def _connect_directly(torrent_id: str, peers_drivers: Sequence[BittorrentDriver]) -> None:
+    def _connect_directly(torrent_id: str, peers_drivers: 'Sequence[BittorrentDriver]') -> None:
         peer_addr = []
         for i, driver in enumerate(peers_drivers):
             peer_addr.append(driver.listen_addr())
@@ -178,7 +179,7 @@ class BittorrentTransfertool(Transfertool):
         self._connect_directly(torrent_id, [dst_driver] + list(src_drivers.values()))
         return torrent_id
 
-    def bulk_query(self, requests_by_eid, timeout: Optional[int] = None) -> Mapping[str, Mapping[str, TransferStatusReport]]:
+    def bulk_query(self, requests_by_eid, timeout: Optional[int] = None) -> 'Mapping[str, Mapping[str, TransferStatusReport]]':
         response = {}
         for transfer_id, requests in requests_by_eid.items():
             for request_id, request in requests.items():
@@ -189,10 +190,10 @@ class BittorrentTransfertool(Transfertool):
                 response.setdefault(transfer_id, {})[request_id] = driver.get_status(request_id=request_id, torrent_id=transfer_id)
         return response
 
-    def query(self, transfer_ids: Sequence[str], details: bool = False, timeout: Optional[int] = None) -> None:
+    def query(self, transfer_ids: 'Sequence[str]', details: bool = False, timeout: Optional[int] = None) -> None:
         pass
 
-    def cancel(self, transfer_ids: Sequence[str], timeout: Optional[int] = None) -> None:
+    def cancel(self, transfer_ids: 'Sequence[str]', timeout: Optional[int] = None) -> None:
         pass
 
     def update_priority(self, transfer_id: str, priority: int, timeout: Optional[int] = None) -> None:

rucio/transfertool/bittorrent_driver.py

@@ -14,14 +14,12 @@
 
 import logging
 from abc import ABCMeta, abstractmethod
-from collections.abc import Sequence
-from typing import TYPE_CHECKING
-
-from rucio.common import types
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
-    from typing import Optional
+    from collections.abc import Sequence
 
+    from rucio.common import types
     from rucio.core.rse import RseData
     from rucio.transfertool.transfertool import TransferStatusReport
 
@@ -32,7 +30,7 @@ class BittorrentDriver(metaclass=ABCMeta):
 
     @classmethod
     @abstractmethod
-    def make_driver(cls: "type[BittorrentDriver]", rse: "RseData", logger: types.LoggerFunction = logging.log) -> "Optional[BittorrentDriver]":
+    def make_driver(cls: "type[BittorrentDriver]", rse: "RseData", logger: 'types.LoggerFunction' = logging.log) -> "Optional[BittorrentDriver]":
         pass
 
     @abstractmethod
@@ -44,7 +42,7 @@ class BittorrentDriver(metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def add_peers(self, torrent_id: str, peers: Sequence[tuple[str, int]]) -> None:
+    def add_peers(self, torrent_id: str, peers: 'Sequence[tuple[str, int]]') -> None:
         pass
 
     @abstractmethod

rucio/transfertool/bittorrent_driver_qbittorrent.py

@@ -13,13 +13,11 @@
 # limitations under the License.
 
 import logging
-from collections.abc import Sequence
 from typing import TYPE_CHECKING, Optional, cast
 from urllib.parse import urlparse
 
 import qbittorrentapi
 
-from rucio.common import types
 from rucio.common.config import get_rse_credentials
 from rucio.common.constants import RseAttr
 from rucio.common.utils import resolve_ip
@@ -30,8 +28,11 @@ from rucio.transfertool.transfertool import TransferStatusReport
 from .bittorrent_driver import BittorrentDriver
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from sqlalchemy.orm import Session
 
+    from rucio.common import types
     from rucio.core.rse import RseData
 
 
@@ -55,10 +56,10 @@ class QBittorrentTransferStatusReport(TransferStatusReport):
         if new_state in [RequestState.FAILED, RequestState.DONE]:
             self.external_id = external_id
 
-    def initialize(self, session: "Session", logger: types.LoggerFunction = logging.log) -> None:
+    def initialize(self, session: "Session", logger: 'types.LoggerFunction' = logging.log) -> None:
         pass
 
-    def get_monitor_msg_fields(self, session: "Session", logger: types.LoggerFunction = logging.log) -> dict[str, str]:
+    def get_monitor_msg_fields(self, session: "Session", logger: 'types.LoggerFunction' = logging.log) -> dict[str, str]:
         return {'protocol': 'qbittorrent'}
 
 
@@ -68,7 +69,7 @@ class QBittorrentDriver(BittorrentDriver):
     required_rse_attrs = (RseAttr.QBITTORRENT_MANAGEMENT_ADDRESS, )
 
     @classmethod
-    def make_driver(cls: "type[QBittorrentDriver]", rse: "RseData", logger: types.LoggerFunction = logging.log) -> "Optional[BittorrentDriver]":
+    def make_driver(cls: "type[QBittorrentDriver]", rse: "RseData", logger: 'types.LoggerFunction' = logging.log) -> "Optional[BittorrentDriver]":
 
         address = rse.attributes.get(RseAttr.QBITTORRENT_MANAGEMENT_ADDRESS)
         if not address:
@@ -96,7 +97,7 @@ class QBittorrentDriver(BittorrentDriver):
             logger=logger,
         )
 
-    def __init__(self, address: str, username: str, password: str, token: Optional[str] = None, logger: types.LoggerFunction = logging.log) -> None:
+    def __init__(self, address: str, username: str, password: str, token: Optional[str] = None, logger: 'types.LoggerFunction' = logging.log) -> None:
         extra_headers = None
         if token:
             extra_headers = {'Authorization': 'Bearer ' + token}
@@ -112,7 +113,7 @@ class QBittorrentDriver(BittorrentDriver):
 
     def listen_addr(self) -> tuple[str, int]:
         preferences = self.client.app_preferences()
-        port = cast(int, preferences['listen_port'])
+        port = cast('int', preferences['listen_port'])
         ip = resolve_ip(urlparse(self.client.host).hostname or self.client.host)
         return ip, port
 
@@ -125,7 +126,7 @@ class QBittorrentDriver(BittorrentDriver):
             is_sequential_download=True,
         )
 
-    def add_peers(self, torrent_id: str, peers: Sequence[tuple[str, int]]) -> None:
+    def add_peers(self, torrent_id: str, peers: 'Sequence[tuple[str, int]]') -> None:
         self.client.torrents_add_peers(torrent_hashes=[torrent_id], peers=[f'{ip}:{port}' for ip, port in peers])
 
     def get_status(self, request_id: str, torrent_id: str) -> TransferStatusReport: