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

rucio/common/config.py

@@ -17,18 +17,23 @@
 import configparser
 import json
 import os
-from collections.abc import Callable
+from functools import cache
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union, overload
 
 from rucio.common import exception
-from rucio.common.exception import ConfigNotFound, DatabaseException
+from rucio.common.exception import ConfigLoadingError, ConfigNotFound, DatabaseException
 
 _T = TypeVar('_T')
 _U = TypeVar('_U')
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from sqlalchemy.orm import Session
 
+LEGACY_SECTION_NAME = {}
+LEGACY_OPTION_NAME = {}
+
 
 def convert_to_any_type(value: str) -> Union[bool, int, float, str]:
     if value.lower() in ['true', 'yes', 'on']:
@@ -110,7 +115,7 @@ def config_get(
         session: "Optional[Session]" = ...,
         use_cache: bool = ...,
         expiration_time: int = ...,
-        convert_type_fnc: Callable[[str], _T],
+        convert_type_fnc: 'Callable[[str], _T]',
 ) -> _T:
     ...
 
@@ -126,7 +131,7 @@ def config_get(
         session: "Optional[Session]" = ...,
         use_cache: bool = ...,
         expiration_time: int = ...,
-        convert_type_fnc: Callable[[str], _U],
+        convert_type_fnc: 'Callable[[str], _U]',
 ) -> Union[_T, _U]:
     ...
 
@@ -143,7 +148,7 @@ def config_get(
         session: "Optional[Session]" = ...,
         use_cache: bool = ...,
         expiration_time: int = ...,
-        convert_type_fnc: Callable[[str], _U],
+        convert_type_fnc: 'Callable[[str], _U]',
 ) -> Union[_T, _U]:
     ...
 
@@ -158,7 +163,7 @@ def config_get(
         session: "Optional[Session]" = None,
         use_cache: bool = True,
         expiration_time: int = 900,
-        convert_type_fnc: Callable[[str], _T] = lambda x: x,
+        convert_type_fnc: 'Callable[[str], _T]' = lambda x: x,
 ) -> Union[_T, _U]:
     """
     Return the string value for a given option in a section
@@ -196,7 +201,7 @@ def config_get(
         except ConfigNotFound:
             pass
 
-        from rucio.common.utils import is_client
+        from rucio.common.client import is_client
         client_mode = is_client()
 
         if not client_mode and check_config_table:
@@ -223,8 +228,6 @@ def get_legacy_config(section: str, option: str):
     :param option: The option of the new config.
     :returns: The string value of the legacy option if one is found, None otherwise.
     """
-    LEGACY_SECTION_NAME = {}
-    LEGACY_OPTION_NAME = {}
 
     section = LEGACY_SECTION_NAME.get(section, section)
     option = LEGACY_OPTION_NAME.get(option, option)
@@ -544,12 +547,12 @@ def config_get_list(
         section: str,
         option: str,
         *,
-        default: list[str] = ...,
+        default: _T = ...,
         check_config_table: bool = ...,
         session: "Optional[Session]" = ...,
         use_cache: bool = ...,
         expiration_time: int = ...,
-) -> list[str]:
+) -> Union[list[str], _T]:
     ...
 
 
@@ -637,7 +640,7 @@ def __config_get_table(
         session: "Optional[Session]" = None,
         use_cache: bool = True,
         expiration_time: int = 900,
-        convert_type_fnc: Optional[Callable[[str], _T]],
+        convert_type_fnc: Optional['Callable[[str], _T]'],
 ) -> _T:
     """
     Search for a section-option configuration parameter in the configuration table
@@ -655,7 +658,6 @@ def __config_get_table(
     :raises ConfigNotFound
     :raises DatabaseException
     """
-    global __CONFIG
     try:
         from rucio.core.config import get as core_config_get
         return core_config_get(section, option, default=default, session=session, use_cache=use_cache,
@@ -664,7 +666,7 @@ def __config_get_table(
         if raise_exception and default is None:
             raise err
         if clean_cached:
-            __CONFIG = None
+            clean_cached_config()
         return default
 
 
@@ -714,14 +716,8 @@ def get_config_dirs() -> list[str]:
     """
     configdirs = []
 
-    if 'RUCIO_HOME' in os.environ:
-        configdirs.append('%s/etc/' % os.environ['RUCIO_HOME'])
-
-    if 'VIRTUAL_ENV' in os.environ:
-        configdirs.append('%s/etc/' % os.environ['VIRTUAL_ENV'])
-
-    if 'CONDA_PREFIX' in os.environ:
-        configdirs.append('%s/etc/' % os.environ['CONDA_PREFIX'])
+    env_vars = ['RUCIO_HOME', 'VIRTUAL_ENV', 'CONDA_PREFIX']
+    configdirs.extend([os.path.join(os.environ[var], 'etc', '') for var in env_vars if var in os.environ])
 
     configdirs.append('/opt/rucio/etc/')
 
@@ -758,21 +754,15 @@ def get_rse_credentials(path_to_credentials_file: Optional[Union[str, os.PathLik
     return credentials
 
 
-__CONFIG = None
-
-
+@cache
 def get_config() -> configparser.ConfigParser:
     """Factory function for the configuration class. Returns the ConfigParser instance."""
-    global __CONFIG
-    if __CONFIG is None:
-        __CONFIG = Config()
-    return __CONFIG.parser
+    return Config().parser
 
 
 def clean_cached_config() -> None:
     """Deletes the cached config singleton instance."""
-    global __CONFIG
-    __CONFIG = None
+    get_config.cache_clear()
 
 
 class Config:
@@ -795,7 +785,4 @@ class Config:
                     '\n\t' + '\n\t'.join(configs))
 
         if not self.parser.read(self.configfile) == [self.configfile]:
-            raise ConfigNotFound(
-                'Could not load Rucio configuration file. '
-                'Rucio tried loading the following configuration file:'
-                '\n\t' + self.configfile)
+            raise ConfigLoadingError(self.configfile)

rucio/common/constants.py

@@ -48,7 +48,7 @@ if config_get_bool('transfers', 'srm_https_compatibility', raise_exception=False
     SCHEME_MAP['srm'].append('davs')
     SCHEME_MAP['davs'].append('srm')
 
-SORTING_ALGORITHMS_LITERAL = Literal['geoip', 'closeness', 'custom_table', 'dynamic', 'ranking', 'random']
+SORTING_ALGORITHMS_LITERAL = Literal['geoip', 'custom_table', 'random']
 SORTING_ALGORITHMS = list(get_args(SORTING_ALGORITHMS_LITERAL))
 
 SUPPORTED_PROTOCOLS_LITERAL = Literal['gsiftp', 'srm', 'root', 'davs', 'http', 'https', 'file', 'storm', 'srm+https', 'scp', 'rsync', 'rclone', 'magnet']
@@ -56,8 +56,11 @@ SUPPORTED_PROTOCOLS: list[str] = list(get_args(SUPPORTED_PROTOCOLS_LITERAL))
 
 RSE_SUPPORTED_PROTOCOL_DOMAINS_LITERAL = Literal['ALL', 'LAN', 'WAN']
 
-RSE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL = Literal['read', 'write', 'delete', 'third_party_copy_read', 'third_party_copy_write']
-RSE_SUPPORTED_PROTOCOL_OPERATIONS: list[str] = list(get_args(RSE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL))
+RSE_BASE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL = Literal['read', 'write', 'delete']
+RSE_BASE_SUPPORTED_PROTOCOL_OPERATIONS: list[str] = list(get_args(RSE_BASE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL))
+
+RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL = Literal[RSE_BASE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL, 'third_party_copy_read', 'third_party_copy_write']
+RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS: list[str] = list(get_args(RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL))
 
 FTS_STATE = namedtuple('FTS_STATE', ['SUBMITTED', 'READY', 'ACTIVE', 'FAILED', 'FINISHED', 'FINISHEDDIRTY', 'NOT_USED',
                                      'CANCELED'])('SUBMITTED', 'READY', 'ACTIVE', 'FAILED', 'FINISHED', 'FINISHEDDIRTY',
@@ -74,12 +77,14 @@ FTS_JOB_TYPE = namedtuple('FTS_JOB_TYPE', ['MULTIPLE_REPLICA', 'MULTI_HOP', 'SES
 MAX_MESSAGE_LENGTH = 4000
 
 
+@enum.unique
 class SuspiciousAvailability(enum.Enum):
     ALL = 0
     EXIST_COPIES = 1
     LAST_COPY = 2
 
 
+@enum.unique
 class ReplicaState(enum.Enum):
     # From rucio.db.sqla.constants, update that file at the same time as this
     AVAILABLE = 'A'
@@ -157,3 +162,56 @@ class RseAttr:
     DEFAULT_LIMIT_FILES = 'default_limit_files'
     QUOTA_APPROVERS = 'quota_approvers'
     RULE_DELETERS = 'rule_deleters'
+
+
+# Literal types to allow overloading of functions with RSE attributes in their signature.
+# RSE attributes are encoded via the BooleanString decorator as VARCHAR in the database,
+# but they are used as either bool or string in the code.
+# This is only determined at runtime, so for static type checking
+# we need to manually specify which attrs are string and which are bool.
+# In future, we could refactor RseAttr to avoid code duplication.
+RSE_ATTRS_STR = Literal[
+    'archive_timeout',
+    'associated_sites',
+    'bittorrent_tracker_addr',
+    'country',
+    'decommission',
+    'default_account_limit_bytes',
+    'fts',
+    'globus_endpoint_id',
+    'lfn2pfn_algorithm',
+    'maximum_pin_lifetime',
+    'multihop_tombstone_delay',
+    'naming_convention',
+    'oidc_base_path',
+    'oidc_support'
+    'physgroup',
+    'qbittorrent_management_address'
+    'rule_approvers',
+    's3_url_style',
+    'simulate_multirange',
+    'site',
+    'source_for_total_space',
+    'source_for_used_space',
+    'staging_buffer',
+    'tombstone_delay',
+    'type'
+]
+
+RSE_ATTRS_BOOL = Literal[
+    'auto_approve_bytes',
+    'auto_approve_files',
+    'block_manual_approval',
+    'greedyDeletion',
+    'is_object_store',
+    'restricted_read',
+    'restricted_write',
+    'skip_upload_stat',
+    'staging_required',
+    'strict_copy',
+    'use_ipv4',
+    'verify_checksum'
+]
+
+SUPPORTED_SIGN_URL_SERVICES_LITERAL = Literal['gcs', 's3', 'swift']
+SUPPORTED_SIGN_URL_SERVICES = list(get_args(SUPPORTED_SIGN_URL_SERVICES_LITERAL))

rucio/common/didtype.py

@@ -16,7 +16,7 @@
 DID type to represent a did and to simplify operations on it
 """
 
-from typing import Union
+from typing import Any, Union
 
 from rucio.common.exception import DIDError
 
@@ -58,6 +58,22 @@ class DID:
         self.scope: str = ''
         self.name: str = ''
 
+        did = self._parse_did_from_args(*args, **kwargs)
+
+        self._construct_did(did)
+
+        if not self.is_valid_format():
+            raise DIDError('Object has invalid format after construction: {}'.format(str(self)))
+
+    def _parse_did_from_args(
+            self,
+            *args,
+            **kwargs
+    ) -> Union["DID", str, tuple[str, str], list[str], dict[str, str]]:
+        """
+        Parse the DID object from the given arguments
+        :return: DID object
+        """
         num_args = len(args)
         num_kwargs = len(kwargs)
         if (num_args + num_kwargs) > 2:
@@ -77,46 +93,78 @@ class DID:
                     else:
                         raise DIDError('Constructor got unexpected keyword argument: {}'.format(k))
                 else:
-                    raise DIDError('First argument of constructor is expected to be string type'
+                    raise DIDError('First argument of constructor is expected to be string type '
                                    'when keyword argument is given. Given type: {}'.format(type(did)))
         elif num_args == 0:
             did = kwargs.get('did', kwargs)
         else:
             did = args
+        return did
 
+    def _construct_did(self, did: Any) -> None:
+        """
+        Construct the DID object from the given input.
+
+        :param did: input to construct the DID object from
+        """
         if isinstance(did, dict):
-            self.scope = did.get('scope', '')
-            self.name = did.get('name', '')
-            if not self.has_scope():
-                self.update_implicit_scope()
+            self._did_from_dict(did)
         elif isinstance(did, tuple) or isinstance(did, list):
-            if len(did) != 2:
-                raise DIDError('Construction from tuple or list requires exactly 2 elements')
-            self.scope = did[0]
-            self.name = did[1]
+            self._did_from_list_or_tuple(did)
         elif isinstance(did, str):
-            did_parts = did.split(DID.SCOPE_SEPARATOR, 1)
-            if len(did_parts) == 1:
-                self.name = did
-                self.update_implicit_scope()
-                if not self.has_scope():
-                    raise DIDError('Object construction from non-splitable string is ambigious')
-            else:
-                self.scope = did_parts[0]
-                self.name = did_parts[1]
+            self._did_from_str(did)
         elif isinstance(did, DID):
-            self.scope = did.scope
-            self.name = did.name
+            self._did_from_did_object(did)
         else:
             raise DIDError('Cannot build object from: {}'.format(type(did)))
 
         if self.name.endswith('/'):
             self.name = self.name[:-1]
 
-        if not self.is_valid_format():
-            raise DIDError('Object has invalid format after construction: {}'.format(str(self)))
+    def _did_from_str(self, did: str) -> None:
+        """
+        Construct the DID from a string.
+        :param did: string containing the DID information
+        """
+        did_parts = did.split(DID.SCOPE_SEPARATOR, 1)
+        if len(did_parts) == 1:
+            self.name = did
+            self._update_implicit_scope()
+            if not self.has_scope():
+                raise DIDError('Object construction from non-splitable string is ambigious')
+        else:
+            self.scope = did_parts[0]
+            self.name = did_parts[1]
+
+    def _did_from_dict(self, did: dict[str, str]) -> None:
+        """
+        Construct the DID from a dictionary.
+        :param did: dictionary optionally containing the keys 'scope' and 'name'
+        """
+        self.scope = did.get('scope', '')
+        self.name = did.get('name', '')
+        if not self.has_scope():
+            self._update_implicit_scope()
+
+    def _did_from_list_or_tuple(self, did: Union[list[str], tuple[str, str]]) -> None:
+        """
+        Construct the DID from a list or tuple.
+        :param did: list or tuple with expected length of 2
+        """
+        if len(did) != 2:
+            raise DIDError('Construction from tuple or list requires exactly 2 elements. Number of elements passed: %i' % len(did))
+        self.scope = did[0]
+        self.name = did[1]
+
+    def _did_from_did_object(self, did: "DID") -> None:
+        """
+        Construct the DID from another DID object.
+        :param did: DID object
+        """
+        self.scope = did.scope
+        self.name = did.name
 
-    def update_implicit_scope(self) -> None:
+    def _update_implicit_scope(self) -> None:
         """
         This method sets the scope if it is implicitly given in self.name
         """

rucio/common/exception.py

@@ -20,6 +20,8 @@
 
 """
 
+from typing import Optional
+
 from rucio.common.constraints import AUTHORIZED_VALUE_TYPES
 
 
@@ -93,11 +95,12 @@ class ClientParameterMismatch(RucioException):
 
 class ClientProtocolNotSupported(RucioException):
     """
-    RucioException
+    Client protocol not supported
     """
-    def __init__(self, *args):
+
+    def __init__(self, host: str, protocol: str, protocols_allowed: Optional[list[str]] = None, *args):
         super(ClientProtocolNotSupported, self).__init__(*args)
-        self._message = "Client protocol not supported."
+        self._message = f"Client protocol '{protocol}' not supported when connecting to host '{host}'.{' Allowed protocols: ' + ', '.join(protocols_allowed) if protocols_allowed else ''}"
         self.error_code = 6
 
 
@@ -1068,14 +1071,14 @@ class PolicyPackageVersionError(PolicyPackageBaseException):
     """
     Policy package is not compatible with this version of Rucio.
     """
-    def __init__(self, package: str, rucio_version: str, supported_versions: list[str], *args):
+    def __init__(self, package: str, rucio_version: str, supported_versionset: str, *args):
         super(PolicyPackageVersionError, self).__init__(package, *args)
         self.rucio_version = rucio_version
-        self.supported_versions = supported_versions
+        self.supported_versionset = supported_versionset
         self._message = 'Policy package %s is not compatible with this Rucio version.\nRucio version: %s\nVersions supported by the package: %s' % (
             self.package,
             self.rucio_version,
-            self.supported_versions
+            self.supported_versionset
         )
         self.error_code = 103
 
@@ -1125,8 +1128,8 @@ class TraceValidationSchemaNotFound(RucioException):
     """
     Trace validation schema not found.
     """
-    def __init__(self, *args, **kwargs):
-        super(TraceValidationSchemaNotFound, self).__init__(*args, **kwargs)
+    def __init__(self, *args):
+        super(TraceValidationSchemaNotFound, self).__init__(*args)
         self._message = 'Trace validation schema not found.'
         self.error_code = 108
 
@@ -1149,3 +1152,57 @@ class UnsupportedMetadataPlugin(RucioException):
         super(UnsupportedMetadataPlugin, self).__init__(*args)
         self._message = "The requested metadata plugin is not enabled on the server."
         self.error_code = 110
+
+
+class ChecksumCalculationError(RucioException):
+    """
+    An error occurred while calculating the checksum.
+    """
+    def __init__(
+            self,
+            algorithm_name: str,
+            filepath: str,
+            *args,
+            **kwargs
+    ):
+        super(ChecksumCalculationError, self).__init__(*args, **kwargs)
+        self.algorithm_name = algorithm_name
+        self.filepath = filepath
+        self._message = 'An error occurred while calculating the %s checksum of file %s.' % (self.algorithm_name, self.filepath)
+        self.error_code = 111
+
+
+class ConfigLoadingError(RucioException):
+    """
+    An error occurred while loading the configuration.
+    """
+    def __init__(
+            self,
+            config_file: str,
+            *args,
+            **kwargs
+    ):
+        super(ConfigLoadingError, self).__init__(*args, **kwargs)
+        self._message = 'Could not load Rucio configuration file. Rucio tried loading the following configuration file:\n\t %s' % (config_file)
+        self.error_code = 112
+
+
+class ClientProtocolNotFound(RucioException):
+    """
+    Missing protocol in client configuration (e.g. no http/https in url).
+    """
+
+    def __init__(self, host: str, protocols_allowed: Optional[list[str]] = None, *args):
+        super(ClientProtocolNotFound, self).__init__(*args)
+        self._message = f"Client protocol missing when connecting to host '{host}'.{' Allowed protocols: ' + ', '.join(protocols_allowed) if protocols_allowed else ''}"
+        self.error_code = 113
+
+
+class ConnectionParameterNotFound(RucioException):
+    """
+    Thrown when a required connection parameter is missing.
+    """
+    def __init__(self, param: str, *args):
+        super(ConnectionParameterNotFound, self).__init__(*args)
+        self._message = f"Required connection parameter '{param}' is not provided."
+        self.error_code = 114

rucio/common/extra.py

@@ -13,24 +13,19 @@
 # limitations under the License.
 
 import importlib
-import warnings
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
-    from typing import Any
+    from collections.abc import Iterable
+    from types import ModuleType
 
 
-def import_extras(module_list: list[str]) -> "dict[str, Any]":
+def import_extras(module_list: 'Iterable[str]') -> dict[str, "Optional[ModuleType]"]:
     out = dict()
     for mod in module_list:
         out[mod] = None
         try:
-            with warnings.catch_warnings():
-                # TODO: remove when https://github.com/paramiko/paramiko/issues/2038 is fixed
-                warnings.filterwarnings('ignore', 'Blowfish has been deprecated', module='paramiko')
-                # TODO: deprecated python 2 and 3.6 too ...
-                warnings.filterwarnings('ignore', 'Python .* is no longer supported', module='paramiko')
-                out[mod] = importlib.import_module(mod)
+            out[mod] = importlib.import_module(mod)
         except ImportError:
             pass
     return out

rucio/common/logging.py

@@ -18,13 +18,13 @@ import json
 import logging
 import re
 import sys
-from collections.abc import Callable, Iterator, Mapping, Sequence
 from traceback import format_tb
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union, get_args
 
 from rucio.common.config import config_get, config_get_bool
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, Mapping, Sequence
     from logging import LogRecord, _SysExcInfoType
 
     from _typeshed import OptExcInfo
@@ -76,7 +76,7 @@ def _json_serializable(obj: Any) -> Union[dict[Any, Any], str]:
         return str(obj)
 
 
-def _navigate_path(obj: Any, path: Sequence[str]) -> Optional[Any]:
+def _navigate_path(obj: Any, path: 'Sequence[str]') -> Optional[Any]:
     """
     Traverse the path in the given object either via attributes or via dict-like subscriptions.
     Returns the found value; None if navigation fails
@@ -136,7 +136,7 @@ def _unflatten_dict(dictionary: dict[str, Any]) -> dict[str, Any]:
     return ret
 
 
-def _get_request_data(request_path: Sequence[str]) -> "Callable[[LogDataSource, LogRecord], Iterator[tuple[str, Optional[Any]]]]":
+def _get_request_data(request_path: 'Sequence[str]') -> "Callable[[LogDataSource, LogRecord], Iterator[tuple[str, Optional[Any]]]]":
     """
     Returns a function which, when called, will resolve the value
     in the flask request object at request_path
@@ -146,7 +146,7 @@ def _get_request_data(request_path: Sequence[str]) -> "Callable[[LogDataSource,
     # TODO: move to top of file once we got rid of/refactored rsemanager
     from flask import has_request_context, request
 
-    def _request_data_formatter(record_formatter: "LogDataSource", record: "LogRecord") -> Iterator[tuple[str, Optional[Any]]]:
+    def _request_data_formatter(record_formatter: "LogDataSource", record: "LogRecord") -> 'Iterator[tuple[str, Optional[Any]]]':
         value = None
         if has_request_context() and request_path:
             value = _navigate_path(request, request_path)
@@ -161,7 +161,7 @@ def _get_record_attribute(attribute: str) -> "Callable[[LogDataSource, LogRecord
     the record passed in argument.
     """
 
-    def _record_attribute_formatter(record_formatter: "LogDataSource", record: "LogRecord") -> Iterator[tuple[str, Optional[Any]]]:
+    def _record_attribute_formatter(record_formatter: "LogDataSource", record: "LogRecord") -> 'Iterator[tuple[str, Optional[Any]]]':
         value = None
         try:
             value = getattr(record, attribute)
@@ -172,7 +172,7 @@ def _get_record_attribute(attribute: str) -> "Callable[[LogDataSource, LogRecord
     return _record_attribute_formatter
 
 
-def _timestamp_formatter(record_formatter: "LogDataSource", record: "LogRecord") -> Iterator[tuple[str, Optional[Any]]]:
+def _timestamp_formatter(record_formatter: "LogDataSource", record: "LogRecord") -> 'Iterator[tuple[str, Optional[Any]]]':
     """
     Format a timestamp
     """
@@ -214,7 +214,7 @@ class LogDataSource:
     def __str__(self):
         return self.__class__.__name__ + '(' + ', '.join(self.ecs_fields) + ')'
 
-    def format(self, record: "LogRecord") -> Optional[Iterator[tuple[str, Any]]]:
+    def format(self, record: "LogRecord") -> Optional['Iterator[tuple[str, Any]]']:
         if not self._formatter:
             return
         for field_name, field_value in self._formatter(self, record):
@@ -241,7 +241,7 @@ class MessageLogDataSource(LogDataSource):
             return exc_info
         return None
 
-    def format(self, record: "LogRecord") -> Iterator[tuple[str, Optional[str]]]:
+    def format(self, record: "LogRecord") -> 'Iterator[tuple[str, Optional[str]]]':
         exc_info = self._get_exc_info(record)
         message = record.getMessage()
         error_type, error_message, stack_trace = None, None, None
@@ -276,7 +276,7 @@ class ConstantStrDataSource(LogDataSource):
         log_record = ECS_TO_LOG_RECORD_MAP.get(ecs_field, None)
         self._str = _str
 
-        def _formatter(data_source: LogDataSource, record: "LogRecord") -> Iterator[tuple[str, str]]:
+        def _formatter(data_source: LogDataSource, record: "LogRecord") -> 'Iterator[tuple[str, str]]':
             yield self.ecs_fields[0], self._str
 
         super().__init__(ecs_fields=(ecs_field,), formatter=_formatter, dst_record_attr=log_record)
@@ -303,7 +303,7 @@ class RucioFormatter(logging.Formatter):
             fmt: Optional[str] = None,
             validate: Optional[bool] = None,
             output_json: bool = False,
-            additional_fields: Optional[Mapping[ECS_FIELDS, str]] = None
+            additional_fields: Optional['Mapping[ECS_FIELDS, str]'] = None
     ):
         _kwargs = {}
         if validate is not None:
@@ -384,7 +384,7 @@ class RucioFormatter(logging.Formatter):
 def rucio_log_formatter(process_name: Optional[str] = None) -> RucioFormatter:
     config_logformat = config_get('common', 'logformat', raise_exception=False, default='%(asctime)s\t%(name)s\t%(process)d\t%(levelname)s\t%(message)s')
     output_json = config_get_bool('common', 'logjson', default=False)
-    additional_fields = {}
+    additional_fields: 'Mapping[ECS_FIELDS, str]' = {}
     if process_name:
         additional_fields['process.name'] = process_name
     return RucioFormatter(fmt=config_logformat, output_json=output_json, additional_fields=additional_fields)
@@ -406,7 +406,7 @@ def setup_logging(application: Optional["Flask"] = None, process_name: Optional[
         application.logger.addHandler(stdouthandler)
 
 
-def formatted_logger(innerfunc: Callable, formatstr: str = "%s") -> Callable:
+def formatted_logger(innerfunc: 'Callable', formatstr: str = "%s") -> 'Callable':
     """
     Decorates the passed function, formatting log input by
     the passed formatstr. The format string must always include a %s.
@@ -415,6 +415,6 @@ def formatted_logger(innerfunc: Callable, formatstr: str = "%s") -> Callable:
     :param formatstr: format string with %s as placeholder.
     """
     @functools.wraps(innerfunc)
-    def log_format(level: int, msg: object, *args, **kwargs) -> Callable:
+    def log_format(level: int, msg: object, *args, **kwargs) -> 'Callable':
         return innerfunc(level, formatstr % msg, *args, **kwargs)
     return log_format