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

rucio/transfertool/fts3_plugins.py

@@ -0,0 +1,152 @@
+# 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 json
+import sys
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
+
+from rucio.common.config import config_get_int
+from rucio.common.exception import InvalidRequest
+from rucio.common.plugins import PolicyPackageAlgorithms
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+FTS3TapeMetadataPluginType = TypeVar('FTS3TapeMetadataPluginType', bound='FTS3TapeMetadataPlugin')
+
+
+class FTS3TapeMetadataPlugin(PolicyPackageAlgorithms):
+    """
+    Add a "archive_metadata" field to a file's transfer parameters.
+    Plugins are registered during initialization and called during a transfer with FTS3
+    """
+
+    ALGORITHM_NAME = "fts3_tape_metadata_plugins"
+    _INIT_FUNC_NAME = "fts3_plugins_init"
+    DEFAULT = "def"
+
+    def __init__(self, policy_algorithm: str) -> None:
+        """
+        :param policy_algorithm: policy algorithm identifier - choose from any of the policy package algorithms registered under the `fts3_tape_metadata_plugins` group.
+        """
+        super().__init__()
+        self.transfer_limit = config_get_int(
+            "transfers",
+            option="metadata_byte_limit",
+            raise_exception=False,
+            default=4096,
+        )
+
+        if not self._supports(self.ALGORITHM_NAME, policy_algorithm):
+            raise ValueError(f'Policy Algorithm {policy_algorithm} not found')
+
+        if self._supports(self._INIT_FUNC_NAME, policy_algorithm):
+            init_func = self._get_one_algorithm(self._INIT_FUNC_NAME, name=policy_algorithm)
+            init_func()
+
+        self.set_in_hints = self._get_one_algorithm(self.ALGORITHM_NAME, name=policy_algorithm)
+
+    @classmethod
+    def _module_init(cls: type[FTS3TapeMetadataPluginType]) -> None:
+        cls.register(cls.DEFAULT, func=lambda x: cls._default(cls, x))  # type: ignore
+
+    @classmethod
+    def register(cls: type[FTS3TapeMetadataPluginType], name: str, func: 'Callable', init_func: Optional['Callable'] = None) -> None:
+        """
+        Register a fts3 transfer plugin
+
+        :param name: name to register under
+        :param func: function called by the plugin
+        :param init_func: Initialization requirements for the plugin, defaults to None
+        """
+        super()._register(cls.ALGORITHM_NAME, algorithm_dict={name: func})
+        if init_func is not None:
+            super()._register(cls._INIT_FUNC_NAME, algorithm_dict={name: init_func})
+
+    @staticmethod
+    def _collocation(collocation_func: 'Callable', hints: dict[str, Any]) -> dict[str, dict]:
+        """
+        Wraps a 'collocation' style plugin for formatting
+
+        :param collocation_func: Function that defines the collocation rules
+        :param hints: kwargs utilized by the collocation rules
+        :return: Collocation hints produced by the collocation_func, wrapped
+        """
+        return {"collocation_hints": collocation_func(**hints)}
+
+    def _default(self, *hints: dict) -> dict:
+        return {}
+
+    def _verify_in_format(self, hint_dict: dict[str, Any]) -> None:
+        """Check the to-be-submitted file transfer params are both json encodable and under the size limit for transfer"""
+        try:
+            hints_json = json.dumps(hint_dict)
+            in_tranfer_limit = sys.getsizeof(hints_json) < self.transfer_limit
+
+        except TypeError as e:
+            raise InvalidRequest("Request malformed, cannot encode to JSON", e)
+
+        if not in_tranfer_limit:
+            raise InvalidRequest(
+                f"Request too large, decrease to less than {self.transfer_limit}"
+            )
+
+    def hints(self, hint_kwargs: dict) -> dict[str, Any]:
+        """
+        Produce "archive_metadata" hints for how a transfer should be executed by fts3.
+
+        :param hint_kwargs: Args passed forward to the plugin algorithm
+        :return: Archiving metadata in the format {archive_metadata: {<plugin produced hints>}}
+        """
+        hints = self.set_in_hints(hint_kwargs)
+        self._verify_in_format(hints)
+        return {"archive_metadata": hints}
+
+
+class ActivityBasedTransferPriorityPlugin(FTS3TapeMetadataPlugin):
+    def __init__(self, policy_algorithm: str = 'activity') -> None:
+        self.register(
+            policy_algorithm,
+            func=lambda x: self._get_activity_priority(x),
+            init_func=self._init_default_priority)
+        super().__init__(policy_algorithm)
+
+    def _init_default_priority(self) -> None:
+        self.default_priority = config_get_int(
+            "tape_priority",
+            option="default",
+            raise_exception=False,
+            default=20,
+        )
+
+    def _get_activity_priority(self, activity_kwargs: dict[str, str]) -> dict[str, dict]:
+        """ Activity Hints - assign a priority based on activity"""
+        if "activity" in activity_kwargs:
+            activity = activity_kwargs["activity"]
+        else:
+            raise InvalidRequest("`activity` field not found in passed metadata")
+
+        priority = config_get_int(
+            "tape_priority",
+            option=activity,
+            raise_exception=False,
+            default=self.default_priority,
+        )
+
+        return {"scheduling_hints": {"priority": priority}}
+
+
+# Register the policies
+FTS3TapeMetadataPlugin._module_init()
+ActivityBasedTransferPriorityPlugin()

rucio/transfertool/globus.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,15 +14,17 @@
 
 import logging
 
+from rucio.common.constants import RseAttr
 from rucio.common.utils import chunks
 from rucio.db.sqla.constants import RequestState
-from rucio.transfertool.transfertool import Transfertool, TransferToolBuilder, TransferStatusReport
-from .globus_library import bulk_submit_xfer, submit_xfer, bulk_check_xfers
+from rucio.transfertool.transfertool import TransferStatusReport, Transfertool, TransferToolBuilder
+
+from .globus_library import bulk_check_xfers, bulk_submit_xfer, submit_xfer
 
 
 def bulk_group_transfers(transfer_paths, policy='single', group_bulk=200):
     """
-    Group transfers in bulk based on certain criterias
+    Group transfers in bulk based on certain criteria
 
     :param transfer_paths:  List of (potentially multihop) transfer paths to group. Each path is a list of single-hop transfers.
     :param policy:          Policy to use to group.
@@ -82,7 +83,7 @@ class GlobusTransferTool(Transfertool):
     """
 
     external_name = 'globus'
-    required_rse_attrs = ('globus_endpoint_id', )
+    required_rse_attrs = (RseAttr.GLOBUS_ENDPOINT_ID, )
 
     def __init__(self, external_host, logger=logging.log, group_bulk=200, group_policy='single'):
         """
@@ -154,15 +155,15 @@ class GlobusTransferTool(Transfertool):
         submitjob = [
             {
                 # Some dict elements are not needed by globus transfertool, but are accessed by further common fts/globus code
-                'sources': [s[1] for s in transfer.legacy_sources],
+                'sources': [transfer.source_url(s) for s in transfer.sources],
                 'destinations': [transfer.dest_url],
                 'metadata': {
                     'src_rse': transfer.src.rse.name,
                     'dst_rse': transfer.dst.rse.name,
                     'scope': str(transfer.rws.scope),
                     'name': transfer.rws.name,
-                    'source_globus_endpoint_id': transfer.src.rse.attributes['globus_endpoint_id'],
-                    'dest_globus_endpoint_id': transfer.dst.rse.attributes['globus_endpoint_id'],
+                    'source_globus_endpoint_id': transfer.src.rse.attributes[RseAttr.GLOBUS_ENDPOINT_ID],
+                    'dest_globus_endpoint_id': transfer.dst.rse.attributes[RseAttr.GLOBUS_ENDPOINT_ID],
                     'filesize': transfer.rws.byte_count,
                 },
             }

rucio/transfertool/globus_library.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,8 +23,8 @@ from rucio.core.monitor import MetricManager
 EXTRA_MODULES = import_extras(['globus_sdk'])
 
 if EXTRA_MODULES['globus_sdk']:
-    from globus_sdk import NativeAppAuthClient, RefreshTokenAuthorizer, TransferClient, TransferData, DeleteData  # pylint: disable=import-error
     import yaml  # pylint: disable=import-error
+    from globus_sdk import DeleteData, NativeAppAuthClient, RefreshTokenAuthorizer, TransferClient, TransferData  # pylint: disable=import-error
 
 METRICS = MetricManager(module=__name__)
 

rucio/transfertool/mock.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,12 +15,17 @@
 import itertools
 import logging
 import uuid
-from typing import TYPE_CHECKING, Any, Optional, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Optional
 
 from rucio.db.sqla.constants import RequestState
-from rucio.transfertool.transfertool import Transfertool, TransferToolBuilder, TransferStatusReport
+from rucio.transfertool.transfertool import TransferStatusReport, Transfertool, TransferToolBuilder
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    from rucio.common.types import LoggerFunction
+    from rucio.core.request import DirectTransfer
     from rucio.db.sqla.session import Session
 
 
@@ -37,10 +41,10 @@ class MockTransferStatusReport(TransferStatusReport):
         self.state = RequestState.DONE
         self.external_id = external_id
 
-    def initialize(self, session: "Session", logger=logging.log):
+    def initialize(self, session: "Session", logger: "LoggerFunction" = logging.log) -> None:
         pass
 
-    def get_monitor_msg_fields(self, session: "Session", logger=logging.log):
+    def get_monitor_msg_fields(self, session: "Session", logger: "LoggerFunction" = logging.log) -> dict[str, Any]:
         return {}
 
 
@@ -53,29 +57,34 @@ class MockTransfertool(Transfertool):
 
     external_name = 'mock'
     required_rse_attrs = ()
+    supported_schemes = {'mock', 'file'}
 
-    def __init__(self, external_host: str, logger=logging.log):
+    def __init__(self, external_host: str, logger: "LoggerFunction" = logging.log):
         super(MockTransfertool, self).__init__(external_host, logger)
 
     @classmethod
-    def submission_builder_for_path(cls, transfer_path, logger=logging.log):
+    def submission_builder_for_path(
+        cls,
+        transfer_path: list["DirectTransfer"],
+        logger: "LoggerFunction" = logging.log
+    ) -> tuple[list["DirectTransfer"], "TransferToolBuilder"]:
         return transfer_path, TransferToolBuilder(cls, external_host='Mock Transfertool')
 
-    def group_into_submit_jobs(self, transfers):
+    def group_into_submit_jobs(self, transfers: "Iterable[list[DirectTransfer]]") -> list[dict[str, Any]]:
         return [{'transfers': list(itertools.chain.from_iterable(transfers)), 'job_params': {}}]
 
-    def submit(self, files, job_params, timeout=None):
+    def submit(self, transfers: "Iterable[DirectTransfer]", job_params: dict[str, str], timeout: Optional[int] = None) -> str:
         return str(uuid.uuid1())
 
-    def bulk_query(self, requests_by_eid: dict[str, dict[str, dict[str, Any]]], timeout: Optional[float] = None):
+    def bulk_query(self, requests_by_eid: "Mapping[str, Mapping[str, Any]]", timeout: Optional[int] = None) -> dict[str, dict[str, MockTransferStatusReport]]:
         response = {}
         for transfer_id, requests in requests_by_eid.items():
             for request_id in requests:
                 response.setdefault(transfer_id, {})[request_id] = MockTransferStatusReport(request_id, transfer_id)
         return response
 
-    def cancel(self, transfer_ids: Sequence[str], timeout: Optional[float] = None):
+    def cancel(self, transfer_ids: Sequence[str], timeout: Optional[int] = None) -> bool:
         return True
 
-    def update_priority(self, transfer_id: str, priority: int, timeout: Optional[float] = None):
+    def update_priority(self, transfer_id: str, priority: int, timeout: Optional[int] = None) -> bool:
         return True

rucio/transfertool/transfertool.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,15 +14,22 @@
 
 import logging
 from abc import ABCMeta, abstractmethod
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
+from rucio.common.constants import SUPPORTED_PROTOCOLS
 from rucio.core.request import get_request
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+
+    from sqlalchemy.orm import Session
+
+    from rucio.common.types import LoggerFunction
+    from rucio.core.request import DirectTransfer
     from rucio.core.rse import RseData
 
 
-class TransferToolBuilder(object):
+class TransferToolBuilder:
     """
     Builder for Transfertool objects.
     Stores the parameters needed to create the Transfertool object of the given type/class.
@@ -31,7 +37,7 @@ class TransferToolBuilder(object):
     Implements __hash__ and __eq__ to allow using it as key in dictionaries and group transfers
     by common transfertool.
     """
-    def __init__(self, transfertool_class, **kwargs):
+    def __init__(self, transfertool_class: type["Transfertool"], **kwargs):
         self.transfertool_class = transfertool_class
         self.fixed_kwargs = frozenset(kwargs.items())
 
@@ -44,13 +50,13 @@ class TransferToolBuilder(object):
     def __eq__(self, other):
         return self.__class__ == other.__class__ and self.__dict__ == other.__dict__
 
-    def make_transfertool(self, **additional_kwargs):
+    def make_transfertool(self, **additional_kwargs) -> "Transfertool":
         all_kwargs = dict(self.fixed_kwargs)
         all_kwargs.update(additional_kwargs)
         return self.transfertool_class(**all_kwargs)
 
 
-class TransferStatusReport(object, metaclass=ABCMeta):
+class TransferStatusReport(metaclass=ABCMeta):
     """
     Allows to compute the changes which have to be applied to the database
     to reflect the current status reported by the external transfertool into
@@ -61,34 +67,34 @@ class TransferStatusReport(object, metaclass=ABCMeta):
         'state',
     ]
 
-    def __init__(self, request_id, request=None):
+    def __init__(self, request_id: str, request: Optional[dict[str, Any]] = None):
         self.request_id = request_id
         self.__request = request  # Optional: DB request. If provided, saves us a database call to fetch it by request_id
         self.__initialized = False
 
-        # Supported db fields bellow
+        # Supported db fields below
         self.state = None
 
     @abstractmethod
-    def initialize(self, session, logger=logging.log):
+    def initialize(self, session: "Session", logger: "LoggerFunction" = logging.log) -> None:
         """
         Initialize all fields from self.supported_update_fields
         """
         pass
 
     @abstractmethod
-    def get_monitor_msg_fields(self, session, logger=logging.log):
+    def get_monitor_msg_fields(self, session: "Session", logger: "LoggerFunction" = logging.log) -> dict[str, Any]:
         """
         Return the fields which will be included in the message sent to hermes.
         """
         pass
 
-    def ensure_initialized(self, session, logger=logging.log):
+    def ensure_initialized(self, session: "Session", logger: "LoggerFunction" = logging.log) -> None:
         if not self.__initialized:
             self.initialize(session, logger)
             self.__initialized = True
 
-    def request(self, session):
+    def request(self, session: "Session") -> Optional[dict[str, Any]]:
         """
         Fetch the request by request_id if needed.
         """
@@ -96,7 +102,7 @@ class TransferStatusReport(object, metaclass=ABCMeta):
             self.__request = get_request(self.request_id, session=session)
         return self.__request
 
-    def get_db_fields_to_update(self, session, logger=logging.log):
+    def get_db_fields_to_update(self, session: "Session", logger: "LoggerFunction" = logging.log) -> dict[str, Any]:
         """
         Returns the fields which have to be updated in the request
         """
@@ -110,15 +116,16 @@ class TransferStatusReport(object, metaclass=ABCMeta):
         return updates
 
 
-class Transfertool(object, metaclass=ABCMeta):
+class Transfertool(metaclass=ABCMeta):
     """
     Interface definition of the Rucio transfertool
     """
 
     external_name = ''
-    required_rse_attrs = ('globus_endpoint_id', )
+    required_rse_attrs = ()
+    supported_schemes = set(SUPPORTED_PROTOCOLS).difference(('magnet', ))
 
-    def __init__(self, external_host, logger=logging.log):
+    def __init__(self, external_host: str, logger: "LoggerFunction" = logging.log):
         """
         Initializes the transfertool
 
@@ -132,7 +139,7 @@ class Transfertool(object, metaclass=ABCMeta):
         return self.external_host if self.external_host is not None else self.__class__.__name__
 
     @classmethod
-    def can_perform_transfer(cls, source_rse: "RseData", dest_rse: "RseData"):
+    def can_perform_transfer(cls, source_rse: "RseData", dest_rse: "RseData") -> bool:
         """
         Return True if this transfertool is able to perform a transfer between the given source and destination rses
         """
@@ -144,12 +151,13 @@ class Transfertool(object, metaclass=ABCMeta):
         return False
 
     @classmethod
-    def submission_builder_for_path(cls, transfer_path, logger=logging.log):
+    @abstractmethod
+    def submission_builder_for_path(cls, transfer_path: list["DirectTransfer"], logger: "LoggerFunction" = logging.log) -> tuple[list["DirectTransfer"], Optional["TransferToolBuilder"]]:
         """
         Analyze the transfer path. If this transfertool class can submit the given transfers, return
         a TransferToolBuilder instance capable to build transfertool objects configured for this
         particular submission.
-        :param transfer_path:  List of DirectTransferDefinitions
+        :param transfer_path:  List of DirectTransfer
         :param logger: logger instance
         :return: a tuple: a sub-path starting at the first node from transfer_path, and a TransfertoolBuilder instance
         capable to submit this sub-path. Returns ([], None) if submission is impossible.
@@ -157,7 +165,8 @@ class Transfertool(object, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def group_into_submit_jobs(self, transfer_paths):
+    @abstractmethod
+    def group_into_submit_jobs(self, transfer_paths: "Iterable[list[DirectTransfer]]") -> list[dict[str, Any]]:
         """
         Takes an iterable over transfer paths, and create groups which can be submitted in one call to submit()
 
@@ -167,7 +176,7 @@ class Transfertool(object, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def submit(self, transfers, job_params, timeout=None):
+    def submit(self, transfers: "Iterable[DirectTransfer]", job_params: dict[str, str], timeout: Optional[int] = None) -> str:
         """
         Submit transfers to the transfertool.
 
@@ -179,7 +188,7 @@ class Transfertool(object, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def bulk_query(self, requests_by_eid, timeout=None) -> dict[str, dict[str, TransferStatusReport]]:
+    def bulk_query(self, requests_by_eid: "Mapping[str, Mapping[str, Any]]", timeout: Optional[int] = None) -> dict[str, dict[str, TransferStatusReport]]:
         """
         Query the status of a bulk of transfers in FTS3 via JSON.
 
@@ -189,7 +198,7 @@ class Transfertool(object, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def cancel(self, transfer_ids, timeout=None):
+    def cancel(self, transfer_ids: "Sequence[str]", timeout: Optional[int] = None) -> None:
         """
         Cancel transfers that have been submitted to the transfertool.
 
@@ -200,7 +209,7 @@ class Transfertool(object, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def update_priority(self, transfer_id, priority, timeout=None):
+    def update_priority(self, transfer_id: str, priority: int, timeout: Optional[int] = None) -> Any:
         """
         Update the priority of a transfer that has been submitted to the transfertool.
 

rucio/vcsversion.py

@@ -4,8 +4,8 @@ This file is automatically generated; Do not edit it. :)
 '''
 VERSION_INFO = {
     'final': True,
-    'version': '32.8.6',
-    'branch_nick': 'release-32-LTS',
-    'revision_id': 'ce0d5e6a899547293697ca2d6b5f6d40467c9d8e',
-    'revno': 12667
+    'version': '35.8.0',
+    'branch_nick': 'release-35-LTS',
+    'revision_id': '8a304950325b8afa9499d3acccb176ef7f93fd07',
+    'revno': 13205
 }

rucio/version.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,34 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-try:
-    from rucio.vcsversion import VERSION_INFO
-except ImportError:
-    VERSION_INFO = {'branch_nick': 'LOCALBRANCH',     # NOQA
-                    'revision_id': 'LOCALREVISION',
-                    'version': 'VERSION',
-                    'final': False,
-                    'revno': 0}
+from rucio.vcsversion import VERSION_INFO
 
 RUCIO_VERSION = [VERSION_INFO['version'], ]
 FINAL = VERSION_INFO['final']   # This becomes true at Release Candidate time
 
 
-def canonical_version_string():
+def canonical_version_string() -> str:
     """ Get the canonical string """
     return '.'.join(filter(None, RUCIO_VERSION))
 
 
-def version_string():
+def version_string() -> str:
     """ Get the version string """
     return canonical_version_string()
 
 
-def vcs_version_string():
+def vcs_version_string() -> str:
     """ Get the VCS version string """
     return "%s:%s" % (VERSION_INFO['branch_nick'], VERSION_INFO['revision_id'])
 
 
-def version_string_with_vcs():
+def version_string_with_vcs() -> str:
     """ Get the version string with VCS """
     return "%s-%s" % (canonical_version_string(), vcs_version_string())

rucio/web/__init__.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

rucio/web/rest/__init__.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

rucio/web/rest/flaskapi/__init__.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

rucio/web/rest/flaskapi/authenticated_bp.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

rucio/web/rest/flaskapi/v1/__init__.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

rucio/web/rest/flaskapi/v1/accountlimits.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,21 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import TYPE_CHECKING
+
 from flask import Flask, request
 
-from rucio.api.account_limit import set_local_account_limit, delete_local_account_limit, set_global_account_limit, \
-    delete_global_account_limit
-from rucio.common.exception import RSENotFound, AccessDenied, AccountNotFound
+from rucio.common.exception import AccessDenied, AccountNotFound, RSENotFound
+from rucio.gateway.account_limit import delete_global_account_limit, delete_local_account_limit, set_global_account_limit, set_local_account_limit
 from rucio.web.rest.flaskapi.authenticated_bp import AuthenticatedBlueprint
-from rucio.web.rest.flaskapi.v1.common import response_headers, ErrorHandlingMethodView, \
-    generate_http_error_flask, json_parameters, param_get
+from rucio.web.rest.flaskapi.v1.common import ErrorHandlingMethodView, generate_http_error_flask, json_parameters, param_get, response_headers
+
+if TYPE_CHECKING:
+    from flask.typing import ResponseReturnValue
 
 
 class LocalAccountLimit(ErrorHandlingMethodView):
-    def post(self, account, rse):
+    def post(self, account: str, rse: str) -> 'ResponseReturnValue':
         """
         ---
-        summary: Create or update a local accont limit
+        summary: Create or update a local account limit
         tags:
           - Account Limit
         parameters:
@@ -78,7 +80,7 @@ class LocalAccountLimit(ErrorHandlingMethodView):
 
         return 'Created', 201
 
-    def delete(self, account, rse):
+    def delete(self, account: str, rse: str) -> 'ResponseReturnValue':
         """
         ---
         summary: Delete a local account limit
@@ -116,7 +118,7 @@ class LocalAccountLimit(ErrorHandlingMethodView):
 
 
 class GlobalAccountLimit(ErrorHandlingMethodView):
-    def post(self, account, rse_expression):
+    def post(self, account: str, rse_expression: str) -> 'ResponseReturnValue':
         """
         ---
         summary: Create or update a global account limit
@@ -176,7 +178,7 @@ class GlobalAccountLimit(ErrorHandlingMethodView):
 
         return 'Created', 201
 
-    def delete(self, account, rse_expression):
+    def delete(self, account: str, rse_expression: str) -> 'ResponseReturnValue':
         """
         ---
         summary: Delete a global account limit
@@ -213,7 +215,7 @@ class GlobalAccountLimit(ErrorHandlingMethodView):
         return '', 200
 
 
-def blueprint(with_doc=False):
+def blueprint(with_doc: bool = False) -> AuthenticatedBlueprint:
     bp = AuthenticatedBlueprint('accountlimits', __name__, url_prefix='/accountlimits')
 
     local_account_limit_view = LocalAccountLimit.as_view('local_account_limit')
@@ -227,7 +229,7 @@ def blueprint(with_doc=False):
     return bp
 
 
-def make_doc():
+def make_doc() -> Flask:
     """ Only used for sphinx documentation """
     doc_app = Flask(__name__)
     doc_app.register_blueprint(blueprint(with_doc=True))