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

rucio/core/rse_counter.py

@@ -178,9 +178,8 @@ def fill_rse_counter_history_table(*, session: "Session"):
 
     :param session: Database session in use.
     """
-    RSEUsageHistory = models.RSEUsageHistory
     stmt = select(
         models.RSEUsage
     )
     for usage in session.execute(stmt).scalars().all():
-        RSEUsageHistory(rse_id=usage['rse_id'], used=usage['used'], files=usage['files'], source=usage['source']).save(session=session)
+        models.RSEUsageHistory(rse_id=usage['rse_id'], used=usage['used'], files=usage['files'], source=usage['source']).save(session=session)

rucio/core/rse_expression_parser.py

@@ -15,11 +15,11 @@
 import abc
 import re
 from hashlib import sha256
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from dogpile.cache.api import NoValue
 
-from rucio.common.cache import make_region_memcached
+from rucio.common.cache import MemcacheRegion
 from rucio.common.exception import InvalidRSEExpression, RSEWriteBlocked
 from rucio.core.rse import get_rse_attribute, get_rses_with_attribute, list_rses
 from rucio.db.sqla.session import transactional_session
@@ -37,7 +37,7 @@ COMPLEMENT = r'(\\%s)' % (PRIMITIVE)
 
 PATTERN = r'^%s(%s|%s|%s)*' % (PRIMITIVE, UNION, INTERSECTION, COMPLEMENT)
 
-REGION = make_region_memcached(expiration_time=600)
+REGION = MemcacheRegion(expiration_time=600)
 
 
 @transactional_session
@@ -286,7 +286,7 @@ class RSEAttributeSmallerCheck(BaseExpressionElement):
         """
         Inherited from :py:func:`BaseExpressionElement.resolve_elements`
         """
-        rse_list = get_rses_with_attribute(key=self.key, session=session)
+        rse_list: list[dict[str, Any]] = get_rses_with_attribute(key=self.key, session=session)
         if not rse_list:
             return (set(), {})
 
@@ -294,7 +294,7 @@ class RSEAttributeSmallerCheck(BaseExpressionElement):
         rse_dict = {}
         for rse in rse_list:
             try:
-                if float(get_rse_attribute(rse['id'], self.key, session=session)) < float(self.value):
+                if float(get_rse_attribute(rse['id'], self.key, session=session)) < float(self.value):  # type: ignore (get_rse_attribute could return None)
                     rse_dict[rse['id']] = rse
                     output.append(rse['id'])
             except ValueError:
@@ -321,7 +321,7 @@ class RSEAttributeLargerCheck(BaseExpressionElement):
         """
         Inherited from :py:func:`BaseExpressionElement.resolve_elements`
         """
-        rse_list = get_rses_with_attribute(key=self.key, session=session)
+        rse_list: list[dict[str, Any]] = get_rses_with_attribute(key=self.key, session=session)
         if not rse_list:
             return (set(), {})
 
@@ -329,7 +329,7 @@ class RSEAttributeLargerCheck(BaseExpressionElement):
         rse_dict = {}
         for rse in rse_list:
             try:
-                if float(get_rse_attribute(rse['id'], self.key, session=session)) > float(self.value):
+                if float(get_rse_attribute(rse['id'], self.key, session=session)) > float(self.value):  # type: ignore (get_rse_attribute could return None)
                     rse_dict[rse['id']] = rse
                     output.append(rse['id'])
             except ValueError:

rucio/core/rse_selector.py

@@ -12,12 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections.abc import Iterable, Sequence
 from random import shuffle, uniform
 from typing import TYPE_CHECKING, Optional
 
 from rucio.common.exception import InsufficientAccountLimit, InsufficientTargetRSEs, InvalidRuleWeight, RSEOverQuota
-from rucio.common.types import InternalAccount
 from rucio.core.account import get_all_rse_usages_per_account, get_usage, has_account_attribute
 from rucio.core.account_limit import get_global_account_limits, get_local_account_limit
 from rucio.core.rse import get_rse_limits, has_rse_attribute, list_rse_attributes
@@ -26,8 +24,12 @@ from rucio.core.rse_expression_parser import parse_expression
 from rucio.db.sqla.session import read_session
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
     from sqlalchemy.orm import Session
 
+    from rucio.common.types import InternalAccount
+
 
 class RSESelector:
     """
@@ -138,9 +140,9 @@ class RSESelector:
     def select_rse(
         self,
         size: int,
-        preferred_rse_ids: Iterable[str],
+        preferred_rse_ids: "Iterable[str]",
         copies: int = 0,
-        blocklist: Optional[Sequence[str]] = None,
+        blocklist: Optional["Sequence[str]"] = None,
         prioritize_order_over_weight: bool = False,
         existing_rse_size: Optional[dict[str, int]] = None
     ) -> list[tuple[str, bool, bool]]:
@@ -258,13 +260,13 @@ class RSESelector:
 @read_session
 def resolve_rse_expression(
     rse_expression: str,
-    account: InternalAccount,
+    account: "InternalAccount",
     weight: Optional[int] = None,
     copies: int = 1,
     ignore_account_limit: bool = False,
     size: int = 0,
-    preferred_rses: Optional[Iterable[str]] = None,
-    blocklist: Optional[Sequence[str]] = None,
+    preferred_rses: Optional["Iterable[str]"] = None,
+    blocklist: Optional["Sequence[str]"] = None,
     prioritize_order_over_weight: bool = False,
     existing_rse_size: Optional[dict[str, int]] = None,
     *,

rucio/core/rule.py

@@ -14,7 +14,6 @@
 
 import json
 import logging
-from collections.abc import Callable, Iterator, Sequence
 from configparser import NoOptionError, NoSectionError
 from copy import deepcopy
 from datetime import datetime, timedelta
@@ -36,7 +35,7 @@ from sqlalchemy.sql.expression import and_, false, null, or_, true, tuple_
 import rucio.core.did
 import rucio.core.lock  # import get_replica_locks, get_files_and_replica_locks_of_dataset
 import rucio.core.replica  # import get_and_lock_file_replicas, get_and_lock_file_replicas_for_dataset
-from rucio.common.cache import make_region_memcached
+from rucio.common.cache import MemcacheRegion
 from rucio.common.config import config_get
 from rucio.common.constants import RseAttr
 from rucio.common.exception import (
@@ -84,10 +83,12 @@ from rucio.db.sqla.constants import OBSOLETE, BadFilesStatus, DIDAvailability, D
 from rucio.db.sqla.session import read_session, stream_session, transactional_session
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, Sequence
+
     from sqlalchemy.orm import Session
 
 
-REGION = make_region_memcached(expiration_time=900)
+REGION = MemcacheRegion(expiration_time=900)
 METRICS = MetricManager(module=__name__)
 AutoApproveT = TypeVar('AutoApproveT', bound='AutoApprove')
 
@@ -113,7 +114,7 @@ class AutoApprove(PolicyPackageAlgorithms):
         return self.get_configured_algorithm()(self.rule, self.did, self.session)
 
     @classmethod
-    def get_configured_algorithm(cls: type[AutoApproveT]) -> Callable[[models.ReplicationRule, models.DataIdentifier, 'Session'], bool]:
+    def get_configured_algorithm(cls: type[AutoApproveT]) -> "Callable[[models.ReplicationRule, models.DataIdentifier, Session], bool]":
         """
         Get the configured auto-approve algorithm
         """
@@ -125,7 +126,7 @@ class AutoApprove(PolicyPackageAlgorithms):
         return super()._get_one_algorithm(cls._algorithm_type, configured_algorithm)
 
     @classmethod
-    def register(cls: type[AutoApproveT], name: str, fn_auto_approve: Callable[[models.ReplicationRule, models.DataIdentifier, 'Session'], bool]) -> None:
+    def register(cls: type[AutoApproveT], name: str, fn_auto_approve: "Callable[[models.ReplicationRule, models.DataIdentifier, Session], bool]") -> None:
         """
         Register a new auto-approve algorithm
         """
@@ -163,7 +164,7 @@ class AutoApprove(PolicyPackageAlgorithms):
 
 @transactional_session
 def add_rule(
-    dids: Sequence[DIDDict],
+    dids: 'Sequence[DIDDict]',
     account: InternalAccount,
     copies: int,
     rse_expression: str,
@@ -477,8 +478,8 @@ def add_rule(
 
 @transactional_session
 def add_rules(
-    dids: Sequence[DIDDict],
-    rules: Sequence[RuleDict],
+    dids: 'Sequence[DIDDict]',
+    rules: 'Sequence[RuleDict]',
     *,
     session: "Session",
     logger: LoggerFunction = logging.log
@@ -954,7 +955,7 @@ def list_rules(
     filters: Optional[dict[str, Any]] = None,
     *,
     session: "Session"
-) -> Iterator[dict[str, Any]]:
+) -> 'Iterator[dict[str, Any]]':
     """
     List replication rules.
 
@@ -1021,7 +1022,7 @@ def list_rule_history(
     rule_id: str,
     *,
     session: "Session"
-) -> Iterator[dict[str, Any]]:
+) -> 'Iterator[dict[str, Any]]':
     """
     List the rule history of a rule.
 
@@ -1055,7 +1056,7 @@ def list_rule_full_history(
     name: str,
     *,
     session: "Session"
-) -> Iterator[dict[str, Any]]:
+) -> 'Iterator[dict[str, Any]]':
     """
     List the rule history of a DID.
 
@@ -1094,7 +1095,7 @@ def list_associated_rules_for_file(
     name: str,
     *,
     session: "Session"
-) -> Iterator[dict[str, Any]]:
+) -> 'Iterator[dict[str, Any]]':
     """
     List replication rules a file is affected from.
 
@@ -2110,7 +2111,7 @@ def get_updated_dids(
     total_workers: int,
     worker_number: int,
     limit: int = 100,
-    blocked_dids: Optional[Sequence[tuple[str, str]]] = None,
+    blocked_dids: Optional['Sequence[tuple[str, str]]'] = None,
     *,
     session: "Session"
 ) -> list[tuple[str, InternalScope, str, DIDReEvaluation]]:
@@ -2196,7 +2197,7 @@ def get_expired_rules(
     total_workers: int,
     worker_number: int,
     limit: int = 100,
-    blocked_rules: Optional[Sequence[str]] = None,
+    blocked_rules: Optional['Sequence[str]'] = None,
     *,
     session: "Session"
 ) -> list[tuple[str, str]]:
@@ -2246,7 +2247,7 @@ def get_injected_rules(
     total_workers: int,
     worker_number: int,
     limit: int = 100,
-    blocked_rules: Optional[Sequence[str]] = None,
+    blocked_rules: Optional['Sequence[str]'] = None,
     *,
     session: "Session"
 ) -> list[str]:
@@ -2295,7 +2296,7 @@ def get_stuck_rules(
     worker_number: int,
     delta: int = 600,
     limit: int = 10,
-    blocked_rules: Optional[Sequence[str]] = None,
+    blocked_rules: Optional['Sequence[str]'] = None,
     *,
     session: "Session"
 ) -> list[str]:
@@ -3152,7 +3153,7 @@ def list_rules_for_rse_decommissioning(
     rse_id: str,
     *,
     session: "Session"
-) -> Iterator[dict[str, Any]]:
+) -> 'Iterator[dict[str, Any]]':
     """Return a generator of rules at the RSE that is being decommissioned.
 
     Decommissioning of an RSE involves deleting or moving away all rules that are
@@ -3215,13 +3216,13 @@ def list_rules_for_rse_decommissioning(
 
 @transactional_session
 def __find_missing_locks_and_create_them(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
+    datasetfiles: 'Sequence[dict[str, Any]]',
+    locks: dict[tuple[InternalScope, str], 'Sequence[models.ReplicaLock]'],
+    replicas: dict[tuple[InternalScope, str], 'Sequence[models.CollectionReplica]'],
+    source_replicas: dict[tuple[InternalScope, str], 'Sequence[models.CollectionReplica]'],
     rseselector: RSESelector,
     rule: models.ReplicationRule,
-    source_rses: Sequence[str],
+    source_rses: 'Sequence[str]',
     *,
     session: "Session",
     logger: LoggerFunction = logging.log
@@ -3273,7 +3274,7 @@ def __find_missing_locks_and_create_them(
 
 @transactional_session
 def __find_surplus_locks_and_remove_them(
-    datasetfiles: Sequence[dict[str, Any]],
+    datasetfiles: 'Sequence[dict[str, Any]]',
     locks: dict[tuple[InternalScope, str], list[models.ReplicaLock]],
     rule: models.ReplicationRule,
     *,
@@ -3324,13 +3325,13 @@ def __find_surplus_locks_and_remove_them(
 
 @transactional_session
 def __find_stuck_locks_and_repair_them(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
+    datasetfiles: 'Sequence[dict[str, Any]]',
+    locks: dict[tuple[InternalScope, str], 'Sequence[models.ReplicaLock]'],
+    replicas: dict[tuple[InternalScope, str], 'Sequence[models.CollectionReplica]'],
+    source_replicas: dict[tuple[InternalScope, str], 'Sequence[models.CollectionReplica]'],
     rseselector: RSESelector,
     rule: models.ReplicationRule,
-    source_rses: Sequence[str],
+    source_rses: 'Sequence[str]',
     *,
     session: "Session",
     logger: LoggerFunction = logging.log
@@ -3802,8 +3803,8 @@ def __evaluate_did_attach(
 def __resolve_did_to_locks_and_replicas(
     did: models.DataIdentifier,
     nowait: bool = False,
-    restrict_rses: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    restrict_rses: Optional['Sequence[str]'] = None,
+    source_rses: Optional['Sequence[str]'] = None,
     only_stuck: bool = False,
     *,
     session: "Session"
@@ -3908,10 +3909,10 @@ def __resolve_did_to_locks_and_replicas(
 
 @transactional_session
 def __resolve_dids_to_locks_and_replicas(
-    dids: Sequence[models.DataIdentifierAssociation],
+    dids: 'Sequence[models.DataIdentifierAssociation]',
     nowait: bool = False,
-    restrict_rses: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    restrict_rses: Optional['Sequence[str]'] = None,
+    source_rses: Optional['Sequence[str]'] = None,
     *,
     session: "Session"
 ) -> tuple[list[dict[str, Any]],
@@ -4078,14 +4079,14 @@ def __resolve_dids_to_locks_and_replicas(
 
 @transactional_session
 def __create_locks_replicas_transfers(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
+    datasetfiles: 'Sequence[dict[str, Any]]',
+    locks: dict[tuple[InternalScope, str], 'Sequence[models.ReplicaLock]'],
+    replicas: dict[tuple[InternalScope, str], 'Sequence[models.CollectionReplica]'],
+    source_replicas: dict[tuple[InternalScope, str], 'Sequence[models.CollectionReplica]'],
     rseselector: RSESelector,
     rule: models.ReplicationRule,
-    preferred_rse_ids: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    preferred_rse_ids: Optional['Sequence[str]'] = None,
+    source_rses: Optional['Sequence[str]'] = None,
     *,
     session: "Session",
     logger: LoggerFunction = logging.log
@@ -4460,7 +4461,7 @@ def archive_localgroupdisk_datasets(
 @read_session
 def get_scratch_policy(
     account: InternalAccount,
-    rses: Sequence[dict[str, Any]],
+    rses: 'Sequence[dict[str, Any]]',
     lifetime: Optional[int],
     *,
     session: "Session"

rucio/core/rule_grouping.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import logging
-from collections.abc import Sequence
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -26,29 +25,32 @@ import rucio.core.replica
 from rucio.common.config import config_get_int
 from rucio.common.constants import RseAttr
 from rucio.common.exception import InsufficientTargetRSEs
-from rucio.common.types import InternalScope
 from rucio.core import account_counter, rse_counter
 from rucio.core import request as request_core
 from rucio.core.rse import get_rse, get_rse_attribute, get_rse_name
-from rucio.core.rse_selector import RSESelector
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import OBSOLETE, DIDType, LockState, ReplicaState, RequestType, RuleGrouping
 from rucio.db.sqla.session import transactional_session
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from sqlalchemy.orm import Session
 
+    from rucio.common.types import InternalScope
+    from rucio.core.rse_selector import RSESelector
+
 
 @transactional_session
 def apply_rule_grouping(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    rseselector: RSESelector,
+    datasetfiles: "Sequence[dict[str, Any]]",
+    locks: dict[tuple["InternalScope", str], "Sequence[models.ReplicaLock]"],
+    replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    source_replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    rseselector: "RSESelector",
     rule: models.ReplicationRule,
-    preferred_rse_ids: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    preferred_rse_ids: Optional["Sequence[str]"] = None,
+    source_rses: Optional["Sequence[str]"] = None,
     *,
     session: "Session"
 ) -> tuple[dict[str, list[dict[str, models.RSEFileAssociation]]],
@@ -116,12 +118,12 @@ def apply_rule_grouping(
 
 @transactional_session
 def repair_stuck_locks_and_apply_rule_grouping(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], models.ReplicaLock],
-    replicas: dict[tuple[InternalScope, str], Any],
-    source_replicas: dict[tuple[InternalScope, str], Any],
-    rseselector: RSESelector, rule: models.ReplicationRule,
-    source_rses: Sequence[str],
+    datasetfiles: "Sequence[dict[str, Any]]",
+    locks: dict[tuple["InternalScope", str], models.ReplicaLock],
+    replicas: dict[tuple["InternalScope", str], Any],
+    source_replicas: dict[tuple["InternalScope", str], Any],
+    rseselector: "RSESelector", rule: models.ReplicationRule,
+    source_rses: "Sequence[str]",
     *,
     session: "Session"
 ) -> tuple[dict[str, list[dict[str, models.RSEFileAssociation]]],
@@ -228,14 +230,14 @@ def create_transfer_dict(dest_rse_id, request_type, scope, name, rule, lock=None
 
 @transactional_session
 def __apply_rule_to_files_none_grouping(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    rseselector: RSESelector,
+    datasetfiles: "Sequence[dict[str, Any]]",
+    locks: dict[tuple["InternalScope", str], "Sequence[models.ReplicaLock]"],
+    replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    source_replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    rseselector: "RSESelector",
     rule: models.ReplicationRule,
-    preferred_rse_ids: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    preferred_rse_ids: Optional["Sequence[str]"] = None,
+    source_rses: Optional["Sequence[str]"] = None,
     *,
     session: "Session"
 ) -> tuple[dict[str, list[dict[str, models.RSEFileAssociation]]],
@@ -329,14 +331,14 @@ def __apply_rule_to_files_none_grouping(
 
 @transactional_session
 def __apply_rule_to_files_all_grouping(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    rseselector: RSESelector,
+    datasetfiles: "Sequence[dict[str, Any]]",
+    locks: dict[tuple["InternalScope", str], "Sequence[models.ReplicaLock]"],
+    replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    source_replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    rseselector: "RSESelector",
     rule: models.ReplicationRule,
-    preferred_rse_ids: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    preferred_rse_ids: Optional["Sequence[str]"] = None,
+    source_rses: Optional["Sequence[str]"] = None,
     *,
     session: "Session"
 ) -> tuple[dict[str, list[dict[str, models.RSEFileAssociation]]],
@@ -480,14 +482,14 @@ def __apply_rule_to_files_all_grouping(
 
 @transactional_session
 def __apply_rule_to_files_dataset_grouping(
-    datasetfiles: Sequence[dict[str, Any]],
-    locks: dict[tuple[InternalScope, str], Sequence[models.ReplicaLock]],
-    replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    source_replicas: dict[tuple[InternalScope, str], Sequence[models.CollectionReplica]],
-    rseselector: RSESelector,
+    datasetfiles: "Sequence[dict[str, Any]]",
+    locks: dict[tuple["InternalScope", str], "Sequence[models.ReplicaLock]"],
+    replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    source_replicas: dict[tuple["InternalScope", str], "Sequence[models.CollectionReplica]"],
+    rseselector: "RSESelector",
     rule: models.ReplicationRule,
-    preferred_rse_ids: Optional[Sequence[str]] = None,
-    source_rses: Optional[Sequence[str]] = None,
+    preferred_rse_ids: Optional["Sequence[str]"] = None,
+    source_rses: Optional["Sequence[str]"] = None,
     *,
     session: "Session"
 ) -> tuple[dict[str, list[dict[str, models.RSEFileAssociation]]],
@@ -1446,7 +1448,7 @@ def apply_rule(did, rule, rses, source_rses, rseselector, *, session: "Session",
             for ds_scope, ds_name in datasets:
                 ds = rucio.core.did.get_did(scope=ds_scope, name=ds_name, dynamic_depth=DIDType.FILE, session=session)  # this will be retrieved again later on -> could be optimized
                 nbytes += ds['bytes']
-                one_rse_coverage = rucio.core.replica.get_RSEcoverage_of_dataset(scope=ds_scope, name=ds_name, session=session)
+                one_rse_coverage = rucio.core.replica.get_rse_coverage_of_dataset(scope=ds_scope, name=ds_name, session=session)
                 for rse_id, bytes_ in one_rse_coverage.items():
                     rse_coverage[rse_id] = bytes_ + rse_coverage.get(rse_id, 0)
 
@@ -1472,7 +1474,7 @@ def apply_rule(did, rule, rses, source_rses, rseselector, *, session: "Session",
 
             if rule.grouping == RuleGrouping.DATASET:
                 # calculate target RSEs
-                rse_coverage = rucio.core.replica.get_RSEcoverage_of_dataset(scope=ds_scope, name=ds_name, session=session)
+                rse_coverage = rucio.core.replica.get_rse_coverage_of_dataset(scope=ds_scope, name=ds_name, session=session)
                 # prnt(rse_coverage)
                 preferred_rse_ids = [x[0] for x in sorted(rse_coverage.items(), key=lambda tup: tup[1], reverse=True)]
                 # prnt(preferred_rse_ids)
@@ -1531,7 +1533,7 @@ def apply_rule(did, rule, rses, source_rses, rseselector, *, session: "Session",
                         # prnt(rse_tuples)
                         # keep track of used RSEs
                         for rt in rse_tuples:
-                            if not rt[0] in used_rse_ids:
+                            if rt[0] not in used_rse_ids:
                                 used_rse_ids.append(rt[0])
 
                     for rse_id, staging_area, availability_write in rse_tuples:

rucio/core/scope.py

@@ -20,7 +20,6 @@ from sqlalchemy import and_, select
 from sqlalchemy.exc import IntegrityError
 
 from rucio.common.exception import AccountNotFound, Duplicate, RucioException, VONotFound
-from rucio.common.types import InternalScope
 from rucio.core.vo import vo_exists
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import AccountStatus, ScopeStatus
@@ -29,6 +28,8 @@ from rucio.db.sqla.session import read_session, transactional_session
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
+    from rucio.common.types import InternalScope
+
 
 @transactional_session
 def add_scope(scope, account, *, session: "Session"):
@@ -69,7 +70,7 @@ def add_scope(scope, account, *, session: "Session"):
 
 
 @read_session
-def bulk_add_scopes(scopes, account, skipExisting=False, *, session: "Session"):
+def bulk_add_scopes(scopes, account, skip_existing=False, *, session: "Session"):
     """ add a group of scopes, this call should not be exposed to users.
 
     :param scopes: a list of scopes to be added.
@@ -81,12 +82,12 @@ def bulk_add_scopes(scopes, account, skipExisting=False, *, session: "Session"):
         try:
             add_scope(scope, account, session=session)
         except Duplicate:
-            if not skipExisting:
+            if not skip_existing:
                 raise
 
 
 @read_session
-def list_scopes(filter_: Optional[dict[str, Any]] = None, *, session: "Session") -> list[InternalScope]:
+def list_scopes(filter_: Optional[dict[str, Any]] = None, *, session: "Session") -> list["InternalScope"]:
     """
     Lists all scopes.
     :param filter_: Dictionary of attributes by which the input data should be filtered

rucio/core/subscription.py

@@ -81,7 +81,6 @@ def add_subscription(name: str,
     except (NoOptionError, NoSectionError, RuntimeError):
         keep_history = False
 
-    SubscriptionHistory = models.SubscriptionHistory
     retroactive = bool(retroactive)  # Force boolean type, necessary for strict SQL
     state = SubscriptionState.ACTIVE
     if retroactive:
@@ -99,18 +98,18 @@ def add_subscription(name: str,
                                            retroactive=retroactive,
                                            policyid=priority, comments=comments)
     if keep_history:
-        subscription_history = SubscriptionHistory(id=new_subscription.id,
-                                                   name=new_subscription.name,
-                                                   filter=new_subscription.filter,
-                                                   account=new_subscription.account,
-                                                   replication_rules=new_subscription.replication_rules,
-                                                   state=new_subscription.state,
-                                                   lifetime=new_subscription.lifetime,
-                                                   retroactive=new_subscription.retroactive,
-                                                   policyid=new_subscription.policyid,
-                                                   comments=new_subscription.comments,
-                                                   created_at=datetime.datetime.utcnow(),
-                                                   updated_at=datetime.datetime.utcnow())
+        subscription_history = models.SubscriptionHistory(id=new_subscription.id,
+                                                          name=new_subscription.name,
+                                                          filter=new_subscription.filter,
+                                                          account=new_subscription.account,
+                                                          replication_rules=new_subscription.replication_rules,
+                                                          state=new_subscription.state,
+                                                          lifetime=new_subscription.lifetime,
+                                                          retroactive=new_subscription.retroactive,
+                                                          policyid=new_subscription.policyid,
+                                                          comments=new_subscription.comments,
+                                                          created_at=datetime.datetime.utcnow(),
+                                                          updated_at=datetime.datetime.utcnow())
     try:
         new_subscription.save(session=session)
         if keep_history:
@@ -171,7 +170,6 @@ def update_subscription(name: str,
         values['state'] = SubscriptionState.INACTIVE
         values['expired_at'] = datetime.datetime.utcnow()
 
-    SubscriptionHistory = models.SubscriptionHistory
     try:
         stmt = select(
             models.Subscription
@@ -191,20 +189,20 @@ def update_subscription(name: str,
 
         subscription.update(values)
         if keep_history and current_subscription_state != new_subscription_state:
-            subscription_history = SubscriptionHistory(id=subscription.id,
-                                                       name=subscription.name,
-                                                       filter=subscription.filter,
-                                                       account=subscription.account,
-                                                       replication_rules=subscription.replication_rules,
-                                                       state=subscription.state,
-                                                       lifetime=subscription.lifetime,
-                                                       retroactive=subscription.retroactive,
-                                                       policyid=subscription.policyid,
-                                                       comments=subscription.comments,
-                                                       last_processed=subscription.last_processed,
-                                                       expired_at=subscription.expired_at,
-                                                       updated_at=datetime.datetime.utcnow(),
-                                                       created_at=subscription.created_at)
+            subscription_history = models.SubscriptionHistory(id=subscription.id,
+                                                              name=subscription.name,
+                                                              filter=subscription.filter,
+                                                              account=subscription.account,
+                                                              replication_rules=subscription.replication_rules,
+                                                              state=subscription.state,
+                                                              lifetime=subscription.lifetime,
+                                                              retroactive=subscription.retroactive,
+                                                              policyid=subscription.policyid,
+                                                              comments=subscription.comments,
+                                                              last_processed=subscription.last_processed,
+                                                              expired_at=subscription.expired_at,
+                                                              updated_at=datetime.datetime.utcnow(),
+                                                              created_at=subscription.created_at)
             subscription_history.save(session=session)
     except NoResultFound:
         raise SubscriptionNotFound(f"Subscription for account '{account}' named '{name}' not found")