rucio 37.0.0rc4__py3-none-any.whl → 37.1.0__py3-none-any.whl

rucio/client/lifetimeclient.py

@@ -39,10 +39,32 @@ class LifetimeClient(BaseClient):
             states: Optional['Sequence[LifetimeExceptionsState]'] = None
     ) -> 'Iterator[dict[str, Any]]':
         """
-        List exceptions to Lifetime Model.
-
-        :param id:         The id of the exception
-        :param states:     The states to filter
+        Lists lifetime model exceptions that allow extending data lifetimes beyond their configured policies.
+
+        The lifetime model exceptions are used to override the default lifecycle policies for data identifiers
+        (files, datasets, containers, or archives) that need to be kept longer than usual. These exceptions
+        can be filtered by their ID or approval state (this feature is not available yet).
+
+        :param exception_id: The unique identifier of a specific exception. If provided, returns only that exception.
+        :param states: Filter exceptions by their states. Possible values are:
+                      - `A` (APPROVED): Exception was approved
+                      - `R` (REJECTED): Exception was rejected
+                      - `W` (WAITING): Exception is waiting for approval by an admin (or other authorized account)
+
+        :returns:
+            An iterator of dictionaries containing the exception details:
+             - `id`: The unique identifier of the exception
+             - `scope`: The scope of the data identifier
+             - `name`: The name of the data identifier
+             - `did_type`: Type of the data identifier:
+                    `F` (file), `D` (dataset), `C` (container), `A` (archive),
+                    `X` (deleted file), `Y` (deleted dataset), `Z` (deleted container)
+             - `account`: The account that requested the exception
+             - `pattern`: Pattern used for matching data identifiers
+             - `comments`: User provided comments explaining the exception
+             - `state`: Current state of the exception
+             - `created_at`: When the exception was created (returned as timestamp string)
+             - `expires_at`: When the exception expires (returned as timestamp string)
         """
 
         path = self.LIFETIME_BASEURL + '/'
@@ -70,16 +92,27 @@ class LifetimeClient(BaseClient):
             expires_at: 'datetime'
     ) -> dict[str, Any]:
         """
-        Add exceptions to Lifetime Model.
-
-        :param dids:        The list of dids
-        :param account:     The account of the requester.
-        :param pattern:     The account.
-        :param comments:    The comments associated to the exception.
-        :param expires_at:  The expiration date of the exception.
-
-        returns:            The id of the exception.
+        Creates a lifetime model exception request to extend the expiration date of data identifiers (DIDs).
+
+        These exceptions allow requesting extensions to DIDs' lifetimes, subject to approval and configured
+        maximum extension periods. The request includes details about which DIDs should have extended
+        lifetimes, who is requesting it, and why it's needed.
+
+        :param dids: List of dictionaries containing the data identifiers to be excepted.
+                    Each dictionary must contain:
+                    - `scope`: The scope of the data identifier
+                    - `name`: The name of the data identifier
+        :param account: The account requesting the exception
+        :param pattern: Associated pattern for the exception request
+        :param comments: Justification for why the exception is needed (e.g. "Needed for my XYZ analysis..")
+        :param expires_at: When the exception should expire (datetime object)
+
+        :returns: A dictionary containing:
+                 - `exceptions`: Dictionary mapping exception IDs to lists of DIDs that were successfully added
+                 - `unknown`: List of DIDs that could not be found
+                 - `not_affected`: List of DIDs that did not qualify for an exception
         """
+
         path = self.LIFETIME_BASEURL + '/'
         url = build_url(choice(self.list_hosts), path=path)
         data = {'dids': dids, 'account': account, 'pattern': pattern, 'comments': comments, 'expires_at': expires_at}

rucio/common/config.py

@@ -31,8 +31,6 @@ if TYPE_CHECKING:
 
     from sqlalchemy.orm import Session
 
-LEGACY_SECTION_NAME = {}
-LEGACY_OPTION_NAME = {}
 
 
 def convert_to_any_type(value: str) -> Union[bool, int, float, str]:
@@ -194,12 +192,6 @@ def config_get(
     try:
         return convert_type_fnc(get_config().get(section, option))
     except (configparser.NoOptionError, configparser.NoSectionError, ConfigNotFound) as err:
-        try:
-            legacy_config = get_legacy_config(section, option)
-            if legacy_config is not None:
-                return convert_type_fnc(legacy_config)
-        except ConfigNotFound:
-            pass
 
         from rucio.common.client import is_client
         client_mode = is_client()
@@ -220,24 +212,6 @@ def config_get(
             return default
 
 
-def get_legacy_config(section: str, option: str):
-    """
-    Returns a legacy config value, if it is present.
-
-    :param section: The section of the new config.
-    :param option: The option of the new config.
-    :returns: The string value of the legacy option if one is found, None otherwise.
-    """
-
-    section = LEGACY_SECTION_NAME.get(section, section)
-    option = LEGACY_OPTION_NAME.get(option, option)
-
-    if config_has_option(section, option):
-        return get_config().get(section, option)
-
-    return None
-
-
 def config_has_section(section: str) -> bool:
     """
     Indicates whether the named section is present in the configuration. The DEFAULT section is not acknowledged.

rucio/common/utils.py

@@ -852,27 +852,24 @@ def get_bytes_value_from_string(input_string: str) -> Union[bool, int]:
     :param input_string: String containing a value and an unit
     :return: Integer value representing the value in bytes
     """
-    result = re.findall('^([0-9]+)([A-Za-z]+)$', input_string)
+    unit_multipliers = {
+        'b': 1,
+        'kb': 10**3,
+        'mb': 10**6,
+        'gb': 10**9,
+        'tb': 10**12,
+        'pb': 10**15,
+    }
+
+    result = re.findall(r'^([0-9]+)([A-Za-z]+)$', input_string)
     if result:
         value = int(result[0][0])
         unit = result[0][1].lower()
-        if unit == 'b':
-            value = value
-        elif unit == 'kb':
-            value = value * 1000
-        elif unit == 'mb':
-            value = value * 1000000
-        elif unit == 'gb':
-            value = value * 1000000000
-        elif unit == 'tb':
-            value = value * 1000000000000
-        elif unit == 'pb':
-            value = value * 1000000000000000
-        else:
+        multiplier = unit_multipliers.get(unit)
+        if multiplier is None:
             return False
-        return value
-    else:
-        return False
+        return value * multiplier
+    return False
 
 
 def parse_did_filter_from_string(input_string: str) -> tuple[dict[str, Any], str]:

rucio/core/account_limit.py

@@ -18,13 +18,16 @@ from sqlalchemy.exc import NoResultFound
 from sqlalchemy.sql import func, literal, select
 from sqlalchemy.sql.expression import and_, or_
 
-from rucio.core.account import get_all_rse_usages_per_account
+from rucio.common.exception import AccountNotFound
+from rucio.core.account import account_exists, get_all_rse_usages_per_account
 from rucio.core.rse import get_rse_name
 from rucio.core.rse_expression_parser import parse_expression
 from rucio.db.sqla import models
 from rucio.db.sqla.session import read_session, transactional_session
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from sqlalchemy.orm import Session
 
     from rucio.common.types import InternalAccount, RSEAccountUsageDict, RSEGlobalAccountUsageDict, RSELocalAccountUsageDict, RSEResolvedGlobalAccountLimitDict
@@ -91,26 +94,39 @@ def get_rse_account_usage(rse_id: str, *, session: "Session") -> list["RSEAccoun
 
 
 @read_session
-def get_global_account_limits(account: Optional["InternalAccount"] = None, *, session: "Session") -> dict[str, "RSEResolvedGlobalAccountLimitDict"]:
+def get_global_account_limit(account: Optional["InternalAccount"] = None, rse_expression: Optional[str] = None, *,
+                             session: "Session") -> Optional[Union[int, float, dict[str, "RSEResolvedGlobalAccountLimitDict"]]]:
     """
-    Returns the global account limits for the account.
+    Returns the global account limit for the given account and RSE expression.
+    If no RSE expression is provided, returns all limits for the given account.
 
-    :param account:  Account to check the limit for.
-    :param session:  Database session in use.
-    :return:         Dict {'MOCK': {'resolved_rses': ['MOCK'], 'limit': 10, 'resolved_rse_ids': [123]}}.
+    Note: The account parameter must always be specified when fetching global account limit for an account.
+
+    :param account:         Account to check the limit for (required unless fetching all limits for all accounts is supported).
+    :param rse_expression:  Specific RSE expression to check the limit for (optional).
+    :param session:         Database session in use.
+    :return:                Limit in Bytes for a single RSE expression, or a dictionary of all limits {'MOCK': {'resolved_rses': ['MOCK'], 'limit': 10, 'resolved_rse_ids': [123]}}.
     """
     if account:
-        stmt = select(
-            models.AccountGlobalLimit
-        ).where(
-            models.AccountGlobalLimit.account == account
-        )
-        global_account_limits = session.execute(stmt).scalars().all()
-    else:
-        stmt = select(
-            models.AccountGlobalLimit
-        )
-        global_account_limits = session.execute(stmt).scalars().all()
+        if not account_exists(account, session=session):
+            raise AccountNotFound(f"Account {account} does not exist")
+        if rse_expression:
+            # Fetch limit for a single RSE expression
+            try:
+                stmt = select(models.AccountGlobalLimit).where(
+                    and_(models.AccountGlobalLimit.account == account,
+                         models.AccountGlobalLimit.rse_expression == rse_expression)
+                )
+                global_account_limit = session.execute(stmt).scalar_one()
+                return float("inf") if global_account_limit.bytes == -1 else global_account_limit.bytes
+            except NoResultFound:
+                return None
+
+    # Fetch all global limits for the account (or all accounts if no account specified)
+    stmt = select(models.AccountGlobalLimit)
+    if account:
+        stmt = stmt.where(models.AccountGlobalLimit.account == account)
+    global_account_limits = session.execute(stmt).scalars().all()
 
     resolved_global_account_limits = {}
     for limit in global_account_limits:
@@ -118,9 +134,7 @@ def get_global_account_limits(account: Optional["InternalAccount"] = None, *, se
             resolved_rses = parse_expression(limit['rse_expression'], filter_={'vo': account.vo}, session=session)
         else:
             resolved_rses = parse_expression(limit['rse_expression'], session=session)
-        limit_in_bytes = limit['bytes']
-        if limit_in_bytes == -1:
-            limit_in_bytes = float('inf')
+        limit_in_bytes = float('inf') if limit['bytes'] == -1 else limit['bytes']
         resolved_global_account_limits[limit['rse_expression']] = {
             'resolved_rses': [resolved_rse['rse'] for resolved_rse in resolved_rses],
             'resolved_rse_ids': [resolved_rse['id'] for resolved_rse in resolved_rses],
@@ -130,69 +144,32 @@ def get_global_account_limits(account: Optional["InternalAccount"] = None, *, se
 
 
 @read_session
-def get_global_account_limit(account: "InternalAccount", rse_expression: str, *, session: "Session") -> Union[int, float, None]:
+def get_local_account_limit(account: "InternalAccount", rse_ids: Optional[Union[str, "Iterable[str]"]] = None, *, session: "Session") -> Optional[Union[int, float, dict[str, int]]]:
     """
-    Returns the global account limit for the account on the rse expression.
-
-    :param account:         Account to check the limit for.
-    :param rse_expression:  RSE expression to check the limit for.
-    :param session:         Database session in use.
-    :return:                Limit in Bytes.
-    """
-    try:
-        stmt = select(
-            models.AccountGlobalLimit
-        ).where(
-            and_(models.AccountGlobalLimit.account == account,
-                 models.AccountGlobalLimit.rse_expression == rse_expression)
-        )
-        global_account_limit = session.execute(stmt).scalar_one()
-        if global_account_limit.bytes == -1:
-            return float("inf")
-        else:
-            return global_account_limit.bytes
-    except NoResultFound:
-        return None
-
-
-@read_session
-def get_local_account_limit(account: "InternalAccount", rse_id: str, *, session: "Session") -> Union[int, float, None]:
-    """
-    Returns the account limit for the account on the rse.
-
-    :param account:  Account to check the limit for.
-    :param rse_id:   RSE id to check the limit for.
-    :param session:  Database session in use.
-    :return:         Limit in Bytes.
-    """
-    try:
-        stmt = select(
-            models.AccountLimit
-        ).where(
-            and_(models.AccountLimit.account == account,
-                 models.AccountLimit.rse_id == rse_id)
-        )
-        account_limit = session.execute(stmt).scalar_one()
-        if account_limit.bytes == -1:
-            return float("inf")
-        else:
-            return account_limit.bytes
-    except NoResultFound:
-        return None
-
-
-@read_session
-def get_local_account_limits(account: "InternalAccount", rse_ids: Optional[list[str]] = None, *, session: "Session") -> dict[str, int]:
-    """
-    Returns the account limits for the account on the list of rses.
+    Returns the local account limit for a given RSE or list of RSEs.
 
     :param account:  Account to check the limit for.
-    :param rse_ids:  List of RSE ids to check the limit for.
+    :param rse_ids:  Single RSE id or an iterable of RSE ids to check the limit for.
     :param session:  Database session in use.
-    :return:         Dictionary {'rse_id': bytes, ...}.
+    :return:         Limit in Bytes (int/float) for a single RSE or
+                     Dictionary {'rse_id': bytes, ...} for multiple RSEs.
     """
+    if not account_exists(account, session=session):
+        raise AccountNotFound(f"Account {account} does not exist")
+    if isinstance(rse_ids, str):  # Single RSE case
+        try:
+            stmt = select(models.AccountLimit).where(
+                and_(models.AccountLimit.account == account, models.AccountLimit.rse_id == rse_ids)
+            )
+            account_limit = session.execute(stmt).scalar_one()
+            return float("inf") if account_limit.bytes == -1 else account_limit.bytes
+        except NoResultFound:
+            return None
 
+    # Multiple RSE case or no RSE specified
     account_limits = {}
+
+    # If rse_ids is a list of RSEs
     if rse_ids:
         rse_id_clauses = []
         for rse_id in rse_ids:
@@ -339,14 +316,14 @@ def get_local_account_usage(account: "InternalAccount", rse_id: Optional[str] =
     )
     if not rse_id:
         # All RSESs
-        limits = get_local_account_limits(account=account, session=session)
+        limits = get_local_account_limit(account=account, session=session)
         counters = {c.rse_id: c for c in session.execute(stmt).scalars().all()}
     else:
         # One RSE
         stmt.where(
             models.AccountUsage.rse_id == rse_id
         )
-        limits = get_local_account_limits(account=account, rse_ids=[rse_id], session=session)
+        limits = get_local_account_limit(account=account, rse_ids=[rse_id], session=session)
         counters = {c.rse_id: c for c in session.execute(stmt).scalars().all()}
     result_list = []
 
@@ -385,7 +362,7 @@ def get_global_account_usage(account: "InternalAccount", rse_expression: Optiona
     result_list = []
     if not rse_expression:
         # All RSE Expressions
-        limits = get_global_account_limits(account=account, session=session)
+        limits = get_global_account_limit(account=account, session=session)
         all_rse_usages = {usage['rse_id']: (usage['bytes'], usage['files']) for usage in get_all_rse_usages_per_account(account=account, session=session)}
         for rse_expression, limit in limits.items():
             usage = 0

rucio/core/did_meta_plugins/filter_engine.py

@@ -102,9 +102,7 @@ class FilterEngine:
             filters, _ = parse_did_filter_from_string_fe(filters, omit_name=True)
         elif isinstance(filters, dict):
             filters = [filters]
-        elif isinstance(filters, list):
-            filters = filters
-        else:
+        elif not isinstance(filters, list):
             raise exception.DIDFilterSyntaxError("Input filters are of an unrecognised type.")
 
         filters = self._make_input_backwards_compatible(filters=filters)

rucio/core/rse_selector.py

@@ -17,7 +17,7 @@ from typing import TYPE_CHECKING, Optional
 
 from rucio.common.exception import InsufficientAccountLimit, InsufficientTargetRSEs, InvalidRuleWeight, RSEOverQuota
 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.account_limit import get_global_account_limit, get_local_account_limit
 from rucio.core.rse import get_rse_limits, has_rse_attribute, list_rse_attributes
 from rucio.core.rse_counter import get_counter as get_rse_counter
 from rucio.core.rse_expression_parser import parse_expression
@@ -86,7 +86,7 @@ class RSESelector:
                 rse['space_left'] = float('inf')
                 rses_with_enough_quota.append(rse)
         else:
-            global_quota_limit = get_global_account_limits(account=account, session=session)
+            global_quota_limit = get_global_account_limit(account=account, session=session)
             all_rse_usages = {usage['rse_id']: usage['bytes'] for usage in get_all_rse_usages_per_account(account=account, session=session)}
             for rse in self.rses:
                 if rse['mock_rse']:
@@ -96,7 +96,7 @@ class RSESelector:
                 else:
                     # check local quota
                     local_quota_left = None
-                    quota_limit = get_local_account_limit(account=account, rse_id=rse['rse_id'], session=session)
+                    quota_limit = get_local_account_limit(account=account, rse_ids=rse['rse_id'], session=session)
                     if quota_limit is None:
                         local_quota_left = 0
                     else:

rucio/core/rule_grouping.py

@@ -1617,4 +1617,3 @@ def apply_rule(did, rule, rses, source_rses, rseselector, *, session: "Session",
         account_counter.increase(rse_id=rse_id, account=rule.account, files=account_counters_files[rse_id], bytes_=account_counters_bytes[rse_id], session=session)
     session.flush()
 
-    return

rucio/gateway/account_limit.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import rucio.common.exception
 import rucio.gateway.permission
@@ -47,110 +47,74 @@ def get_rse_account_usage(
     return [gateway_update_return_dict(d, session=session) for d in account_limit_core.get_rse_account_usage(rse_id=rse_id, session=session)]
 
 
-@read_session
-def get_local_account_limits(
-    account: str,
-    vo: str = 'def',
-    *,
-    session: "Session"
-) -> dict[str, Any]:
-    """
-    Lists the limitation names/values for the specified account name.
-
-    REST API: http://<host>:<port>/rucio/account/<account>/limits
-
-    :param account:     The account name.
-    :param vo:          The VO to act on.
-    :param session:     The database session in use.
-
-    :returns: The account limits.
-    """
-
-    internal_account = InternalAccount(account, vo=vo)
-
-    rse_instead_id = {}
-    for elem in account_limit_core.get_local_account_limits(account=internal_account, session=session).items():
-        rse_instead_id[get_rse_name(rse_id=elem[0], session=session)] = elem[1]
-    return rse_instead_id
-
-
 @read_session
 def get_local_account_limit(
-    account: str,
-    rse: str,
-    vo: str = 'def',
-    *,
-    session: "Session"
+        account: str,
+        rse: Optional[str] = None,
+        vo: str = 'def',
+        *,
+        session: "Session"
 ) -> dict[str, Union[int, float, None]]:
     """
-    Lists the limitation names/values for the specified account name and rse name.
+    Lists the limitation names/values for the specified account name.
+    If an RSE is provided, it returns the limit for that specific RSE.
+    Otherwise, it returns all account limits.
 
     REST API: http://<host>:<port>/rucio/account/<account>/limits
 
-    :param account:     The account name.
-    :param rse:         The rse name.
-    :param vo:          The VO to act on.
-    :param session:     The database session in use.
+    :param account: The account name.
+    :param rse: The RSE name (optional).
+    :param vo: The VO to act on.
+    :param session: The database session in use.
 
-    :returns: The account limit.
+    :returns: A dictionary of account limits with RSE names as keys and limits as values.
     """
 
     internal_account = InternalAccount(account, vo=vo)
 
-    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
-    return {rse: account_limit_core.get_local_account_limit(account=internal_account, rse_id=rse_id, session=session)}
-
-
-@read_session
-def get_global_account_limits(
-    account: str,
-    vo: str = 'def',
-    *,
-    session: "Session"
-) -> dict[str, RSEResolvedGlobalAccountLimitDict]:
-    """
-    Lists the limitation names/values for the specified account name.
-
-    REST API: http://<host>:<port>/rucio/account/<account>/limits
-
-    :param account:     The account name.
-    :param vo:          The VO to act on.
-    :param session:     The database session in use.
-
-    :returns: The account limits.
-    """
-    if account:
-        internal_account = InternalAccount(account, vo=vo)
+    if rse:
+        # Single RSE lookup
+        rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+        return {rse: account_limit_core.get_local_account_limit(account=internal_account, rse_ids=rse_id, session=session)}
     else:
-        internal_account = InternalAccount('*', vo=vo)
-
-    return account_limit_core.get_global_account_limits(account=internal_account, session=session)
+        # Fetch all RSE limits
+        limits = account_limit_core.get_local_account_limit(account=internal_account, rse_ids=None, session=session)
+        return {get_rse_name(rse_id=rse_id, session=session): limit for rse_id, limit in limits.items()}
 
 
 @read_session
 def get_global_account_limit(
-    account: str,
-    rse_expression: str,
-    vo: str = 'def',
-    *,
-    session: "Session"
-) -> dict[str, dict[str, RSEResolvedGlobalAccountLimitDict]]:
+        account: str,
+        rse_expression: Optional[str] = None,
+        vo: str = 'def',
+        *,
+        session: "Session"
+) -> Union[dict[str, RSEResolvedGlobalAccountLimitDict], dict[str, dict[str, RSEResolvedGlobalAccountLimitDict]]]:
     """
-    Lists the limitation names/values for the specified account name and rse expression.
+    Lists the global account limitation names/values for the specified account.
+    If an RSE expression is provided, fetches the limit for that expression.
+    Otherwise, fetches all global limits for the account.
 
     REST API: http://<host>:<port>/rucio/account/<account>/limits
 
     :param account:         The account name.
-    :param rse_expression:  The rse expression.
+    :param rse_expression:  The RSE expression (optional; if not provided, all limits will be fetched).
     :param vo:              The VO to act on.
     :param session:         The database session in use.
 
-    :returns: The account limit.
+    :returns:
+        - If `rse_expression` is provided: `{rse_expression: {...}}`
+        - If `rse_expression` is not provided: `{...}` (dictionary of all limits).
     """
 
     internal_account = InternalAccount(account, vo=vo)
 
-    return {rse_expression: account_limit_core.get_global_account_limit(account=internal_account, rse_expression=rse_expression, session=session)}
+    if rse_expression:
+        return {rse_expression: account_limit_core.get_global_account_limit(
+            account=internal_account, rse_expression=rse_expression, session=session
+        )}
+
+    return account_limit_core.get_global_account_limit(account=internal_account, session=session)
 
 
 @transactional_session

rucio/transfertool/fts3.py

@@ -607,7 +607,7 @@ class Fts3TransferStatusReport(TransferStatusReport):
             'src-type': self._file_metadata.get('src_type'),
             'src-rse': self._src_rse,
             'src-url': self._src_url,
-            'dst-type': self._file_metadata.get('src_type'),
+            'dst-type': self._file_metadata.get('dst_type'),
             'dst-rse': self._file_metadata.get('dst_rse'),
             'dst-url': self._dst_url,
             'started_at': self.started_at,

rucio/vcsversion.py

@@ -4,8 +4,8 @@ This file is automatically generated; Do not edit it. :)
 '''
 VERSION_INFO = {
     'final': True,
-    'version': '37.0.0rc4',
-    'branch_nick': 'master',
-    'revision_id': '9df77d169e527191a39190f0c041a668dc411509',
-    'revno': 13615
+    'version': '37.1.0',
+    'branch_nick': 'release-37',
+    'revision_id': 'f6fa712c32b14e1d104349a1c2596cdcb4d8d92d',
+    'revno': 13640
 }

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

@@ -21,7 +21,7 @@ from flask import Flask, Response, jsonify, redirect, request
 from rucio.common.exception import AccessDenied, AccountNotFound, CounterNotFound, Duplicate, IdentityError, InvalidObject, RSENotFound, RuleNotFound, ScopeNotFound
 from rucio.common.utils import APIEncoder, render_json
 from rucio.gateway.account import add_account, add_account_attribute, del_account, del_account_attribute, get_account_info, get_usage_history, list_account_attributes, list_accounts, list_identities, update_account
-from rucio.gateway.account_limit import get_global_account_limit, get_global_account_limits, get_global_account_usage, get_local_account_limit, get_local_account_limits, get_local_account_usage
+from rucio.gateway.account_limit import get_global_account_limit, get_global_account_usage, get_local_account_limit, get_local_account_usage
 from rucio.gateway.identity import add_account_identity, del_account_identity
 from rucio.gateway.rule import list_replication_rules
 from rucio.gateway.scope import add_scope, get_scopes
@@ -561,10 +561,7 @@ class LocalAccountLimits(ErrorHandlingMethodView):
             description: Not Acceptable
         """
         try:
-            if rse:
-                limits = get_local_account_limit(account=account, rse=rse, vo=request.environ.get('vo'))
-            else:
-                limits = get_local_account_limits(account=account, vo=request.environ.get('vo'))
+            limits = get_local_account_limit(account=account, rse=rse, vo=request.environ.get('vo'))
         except RSENotFound as error:
             return generate_http_error_flask(404, error)
 
@@ -609,10 +606,7 @@ class GlobalAccountLimits(ErrorHandlingMethodView):
             description: Not Acceptable
         """
         try:
-            if rse_expression:
-                limits = get_global_account_limit(account=account, rse_expression=rse_expression, vo=request.environ.get('vo'))
-            else:
-                limits = get_global_account_limits(account=account, vo=request.environ.get('vo'))
+            limits = get_global_account_limit(account=account, rse_expression=rse_expression, vo=request.environ.get('vo'))
         except RSENotFound as error:
             return generate_http_error_flask(404, error)
 

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

@@ -22,7 +22,7 @@ from flask import Blueprint, Flask, Response, redirect, render_template, request
 from werkzeug.datastructures import Headers
 
 from rucio.common.config import config_get
-from rucio.common.exception import AccessDenied, CannotAuthenticate, CannotAuthorize, IdentityError, IdentityNotFound
+from rucio.common.exception import AccessDenied, CannotAuthenticate, CannotAuthorize, ConfigurationError, IdentityError, IdentityNotFound, InvalidRequest
 from rucio.common.extra import import_extras
 from rucio.common.utils import date_to_str
 from rucio.core.authentication import strip_x509_proxy_attributes
@@ -697,7 +697,7 @@ class TokenOIDC(ErrorHandlingMethodView):
             # response.set_cookie('rucio-auth-token-created-at', value=str(time.time()))
             return response
         else:
-            return '', 400, headers
+            return generate_http_error_flask(status_code=400, exc=InvalidRequest.__name__, exc_msg="", headers=headers)
 
 
 class RefreshOIDC(ErrorHandlingMethodView):
@@ -1444,7 +1444,7 @@ class SAML(ErrorHandlingMethodView):
         headers.set('Pragma', 'no-cache')
 
         if not EXTRA_MODULES['onelogin']:
-            return "SAML not configured on the server side.", 400, headers
+            return generate_http_error_flask(status_code=400, exc=ConfigurationError.__name__, exc_msg="SAML not configured on the server side.", headers=headers)
 
         saml_nameid = request.cookies.get('saml-nameid', default=None)
         vo = extract_vo(request.headers)