rucio-clients 35.5.0__tar.gz → 36.0.0__tar.gz

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/AUTHORS.rst

@@ -67,6 +67,7 @@ Individual contributors to the source code
 - Aksel Lunde Aase <aksel.lunde.aase@gmail.com>, 2022
 - Elena Gazzarrini <gazzarrini.elena@gmail.com>, 2022-2023
 - Maximilian Linhoff, <maximilian.linhoff@tu-dortmund.de>, 2024
+- Eric Banzuzi, <eric.banzuzi@gmail.com>, 2024
 
 Organisations employing contributors
 ------------------------------------

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rucio-clients
-Version: 35.5.0
+Version: 36.0.0
 Summary: Rucio Client Lite Package
 Home-page: https://rucio.cern.ch/
 Author: Rucio
@@ -24,6 +24,8 @@ Requires-Dist: urllib3>=1.26.18
 Requires-Dist: dogpile-cache>=1.2.2
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: jsonschema>=4.20.0
+Requires-Dist: packaging>=24.1
+Requires-Dist: rich>=13.7.1
 Provides-Extra: ssh
 Requires-Dist: paramiko>=3.4.0; extra == "ssh"
 Provides-Extra: kerberos

rucio_clients-36.0.0/bin/rucio

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+# 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 argparse
+import sys
+from typing import Optional
+
+from rucio.client.commands.bin_legacy.rucio import main as main_legacy
+from rucio.client.commands.command import main
+
+
+def make_warning():
+    base_warning = "\nWARNING: This method is being deprecated."
+    new_command = map_legacy_command()
+    if new_command is not None:
+        warning = f"{base_warning}\nPlease replace your command with `rucio {' '.join(new_command)}`.\n"
+    else:
+        warning = base_warning + "\nPlease view rucio -h for an updated help menu.\n"
+
+    return warning
+
+
+def map_legacy_command() -> Optional[list[str]]:
+    try:
+        command = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--version")][1]
+    except IndexError:
+        command = None
+
+    new_command = None
+    if command not in ("-h", "--version", None):
+        command_map = {
+            "list-file-replicas": ["replica", "list"],
+            "list-dataset-replicas": ["replica", "dataset"],
+            "add-dataset": ["did", "add", "--type dataset"],
+            "add-container": ["did", "add", "--type container"],
+            "attach": ["did", "content", "add"],
+            "detach": ["did", "content", "remove"],
+            "ls": ["did", "list"],
+            "list-dids": ["did", "list"],
+            "list-parent-dids": ["did", "show", "--parent"],
+            "list-scopes": ["scope", "list"],
+            "close": ["did", "update", "--close"],
+            "reopen": ["did", "update", "--open"],
+            "stat": ["did", "show"],
+            "erase": ["did", "remove"],
+            "list-content": ["did", "content", "list"],
+            "list-content-history": ["did", "content", "history"],
+            "upload": ["upload"],
+            "get": ["download"],
+            "download": ["download"],
+            "get-metadata": ["did", "metadata", "list"],
+            "set-metadata": ["did", "metadata", "add"],
+            "delete-metadata": ["did", "metadata", "remove"],
+            "list-rse-usage": ["rse", "show"],
+            "list-account-usage": ["account", "usage"],
+            "list-account-limits": ["account", "limit", "list"],
+            "add-rule": ["rule", "add"],
+            "delete-rule": ["rule", "remove"],
+            "rule-info": ["rule", "info"],
+            "list-rules": ["rule", "list"],
+            "list-rules-history": ["rule", "history"],
+            "update-rule": ["rule", "update"],
+            "move-rule": ["rule", "update", "--move"],
+            "list-rses": ["rse", "list"],
+            "list-suspicious-replicas": ["replica", "state", "suspicious"],
+            "list-rse-attributes": ["rse", "attribute", "list"],
+            "touch": ["did", "update", "--touch"],
+            "add-lifetime-exception": ["lifetime-exception", "add"],
+        }
+        try:
+            new_command = command_map[command]
+        except KeyError:
+            pass
+
+    return new_command
+
+
+if __name__ == "__main__":
+    commands = ("-h", "--version", "account", "config", "did", "replica", "rse", "rule", "scope", "subscription", "ping", "whoami", "test-server", "lifetime-exception", "upload", "download")
+    first_command = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--help", "--version")][1]
+    is_legacy = '--legacy' in sys.argv
+
+    if (first_command in commands) and not is_legacy:
+        main()
+
+    elif is_legacy:
+        warning = make_warning()
+        print(warning)
+        sys.argv.pop(sys.argv.index('--legacy'))
+        main_legacy()
+
+    else:
+        warning = make_warning()
+        print(warning)
+        try:
+            main_legacy()
+        # Make a custom warning - show the new help menu when invalid commands are called.
+        except argparse.ArgumentError:
+            print("Invalid argument(s) - %s " % sys.argv[1:])
+            command = map_legacy_command()
+            if command is not None:
+                sys.argv = ["rucio"] + command + ["-h"]
+            else:
+                sys.argv = ["rucio", "-h"]
+
+            main()

rucio_clients-36.0.0/bin/rucio-admin

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# 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 sys
+
+from rucio.client.commands.bin_legacy.rucio_admin import main as main_legacy
+
+
+def make_warning():
+    base_warning = "\nWARNING: This method is being deprecated."
+    args = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--help", "--version")]
+    first_command = args[1]
+    try:
+        second_command = args[2]
+    except IndexError:
+        second_command = "-h"
+
+    if first_command not in ("-h", "--version", "--help"):
+        command_map = {
+            "data": {"-h": "did -h", "import": "did upload", "export": "did download"},
+            "account": {
+                "-h": "account -h",
+                "add": "account add",
+                "delete": "account remove",
+                "info": "account show",
+                "update": "account update",
+                "set-limits": "account limit add",
+                "get-limits": "account limit list",
+                "delete-limits": "account limit remove",
+                "ban": "account update --ban True",
+                "unban": "account update --ban False",
+                "list-attributes": "account attribute list",
+                "add-attribute": "account attribute add",
+                "delete-attribute": "account attribute remove",
+            },
+            "identity": {"-h": "account identity -h", "add": "account identity add", "delete": "account identity remove"},
+            "rse": {
+                "-h": "rse -h",
+                "add": "rse add",
+                "list": "rse",
+                "update": "rse update",
+                "info": "rse info",
+                "set-attribute": "rse attribute add",
+                "delete-attribute": "rse attribute remove",
+                "delete-distance": "rse distance remove",
+                "get-distance": "rse distance list",
+                "get-attribute": "rse attribute list",
+                "add-protocol": "rse protocol add",
+                "delete-protocol": "rse protocol remove",
+                "delete": "rse remove",
+                "add-qos-policy": "rse qos add",
+                "add-distance": "rse distance add",
+                "delete-qos-policy": "rse qos remove",
+                "list-qos-policies": "rse qos list",
+                "set-limit": "rse limit add",
+                "delete-limit": "rse limit remove",
+            },
+            "scope": {"-h": "scope -h", "add": "scope add", "list": "scope list"},
+            "config": {"-h": "config -h", "get": "config list", "set": "config add", "delete": "config remove"},
+            "subscription": {"-h": "subscription -h", "add": "subscription add", "list": "subscription", "update": "subscription update", "reevaluate": "subscription touch"},
+            "replicas": {"-h": "replica -h", "quarantine": "replica state quarantine", "declare-bad": "replica state bad", "declare-temporary-unavailable": "replica state temp-unavailable", "list-pfns": "replica pfn", "set-tombstone": "replica tombstone"},
+        }
+        try:
+            new_command = command_map[first_command]
+            new_command = new_command[second_command]
+        except KeyError:
+            new_command = "-h"
+
+        warning = f"{base_warning}\nPlease replace your command with `rucio {new_command}`.\n"
+    else:
+        warning = base_warning + "\nPlease view rucio -h for an updated help menu.\n"
+
+    print(warning)
+
+
+if __name__ == "__main__":
+    make_warning()
+    main_legacy()

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/etc/rucio.cfg.atlas.client.template

@@ -29,8 +29,9 @@ request_retries = 3
 auth_type = x509_proxy
 
 [policy]
-permission = atlas
-schema = atlas
+package = atlas_rucio_policy_package
+#permission = atlas
+#schema = atlas
 lfn2pfn_algorithm_default = hash
 support = hn-atlas-dist-analysis-help@cern.ch
 support_rucio = https://github.com/rucio/rucio/issues/

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/etc/rucio.cfg.template

@@ -229,9 +229,10 @@ panda_url = http://bigpanda.cern.ch/jobs/?category=analysis&jobstatus=running
 window = 604800
 
 [policy]
-package = ATLASRucioPolicy
+package = atlas_rucio_policy_package
 permission = atlas
 schema = atlas
+extract_scope = atlas
 lfn2pfn_algorithm_default = hash
 support = hn-atlas-dist-analysis-help@cern.ch
 support_rucio = https://github.com/rucio/rucio/issues/

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/lib/rucio/client/baseclient.py

@@ -22,13 +22,11 @@ import os
 import secrets
 import sys
 import time
-from collections.abc import Generator
 from configparser import NoOptionError, NoSectionError
-from logging import Logger
 from os import environ, fdopen, geteuid, makedirs, path
 from shutil import move
 from tempfile import mkstemp
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import urlparse
 
 import requests
@@ -44,6 +42,10 @@ from rucio.common.exception import CannotAuthenticate, ClientProtocolNotSupporte
 from rucio.common.extra import import_extras
 from rucio.common.utils import build_url, get_tmp_dir, my_key_generator, parse_response, setup_logger, ssh_sign
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from logging import Logger
+
 EXTRA_MODULES = import_extras(['requests_kerberos'])
 
 if EXTRA_MODULES['requests_kerberos']:
@@ -90,7 +92,7 @@ class BaseClient:
                  timeout: Optional[int] = 600,
                  user_agent: Optional[str] = 'rucio-clients',
                  vo: Optional[str] = None,
-                 logger: Logger = LOG) -> None:
+                 logger: 'Logger' = LOG) -> None:
         """
         Constructor of the BaseClient.
         :param rucio_host: The address of the rucio server, if None it is read from the config file.
@@ -364,7 +366,7 @@ class BaseClient:
         else:
             return exception.RucioException, "%s: %s" % (exc_cls, exc_msg)
 
-    def _load_json_data(self, response: requests.Response) -> Generator[Any, Any, Any]:
+    def _load_json_data(self, response: requests.Response) -> 'Generator[Any, Any, Any]':
         """
         Helper method to correctly load json data based on the content type of the http response.
 

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/lib/rucio/client/downloadclient.py

@@ -29,11 +29,13 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from rucio import version
 from rucio.client.client import Client
+from rucio.common.checksum import CHECKSUM_ALGO_DICT, GLOBALLY_SUPPORTED_CHECKSUMS, PREFERRED_CHECKSUM, adler32
+from rucio.common.client import detect_client_location
 from rucio.common.config import config_get
 from rucio.common.didtype import DID
 from rucio.common.exception import InputValidationError, NoFilesDownloaded, NotAllFilesDownloaded, RucioException
 from rucio.common.pcache import Pcache
-from rucio.common.utils import CHECKSUM_ALGO_DICT, GLOBALLY_SUPPORTED_CHECKSUMS, PREFERRED_CHECKSUM, adler32, detect_client_location, execute, extract_scope, generate_uuid, parse_replicas_from_file, parse_replicas_from_string, send_trace, sizefmt
+from rucio.common.utils import execute, extract_scope, generate_uuid, parse_replicas_from_file, parse_replicas_from_string, send_trace, sizefmt
 from rucio.rse import rsemanager as rsemgr
 
 if TYPE_CHECKING:

rucio_clients-36.0.0/lib/rucio/client/richclient.py

@@ -0,0 +1,324 @@
+# 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 logging
+import pydoc
+import re
+import subprocess
+import sys
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+from rich import box
+from rich.console import Console, JustifyMethod, RenderableType
+from rich.logging import RichHandler
+from rich.table import Table
+from rich.text import Text
+
+from rucio.common.config import config_get
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from rich.style import StyleType
+
+
+MIN_CONSOLE_WIDTH = 80
+MAX_TRACEBACK_WIDTH = 120  # Slightly higher than default width of rich.traceback (100).
+
+
+class CLITheme:
+    """
+    Class to define styles for Rich widgets and prints in the CLI.
+    """
+    TABLE_FMT = box.SQUARE
+
+    TEXT_HIGHLIGHT = 'grey50'  # Used to highlight prints between tables, e.g. get_metadata or stat.
+    SUBHEADER_HIGHLIGHT = 'cyan'  # Used to highlight prints between tables for a section, e.g. protocols or usage per account.
+    SPINNER = 'dots2'
+    SPINNER_STYLE = 'green'
+
+    JSON_STR = 'green'
+    JSON_NUM = 'bold cyan'
+
+    SUCCESS_ICON = '[bold green]\u2714[/]'
+    FAILURE_ICON = '[bold red]\u2717[/]'
+
+    LOG_THEMES = {
+        'logging.level.info': 'default',
+        'logging.level.warning': 'bold yellow',
+        'logging.level.debug': 'dim',
+        'logging.level.critical': 'default on red',
+        'repr.bool_true': 'green',
+        'repr.bool_false': 'red',
+        'log.time': 'turquoise4'
+    }
+
+    DID_TYPE = {
+        'CONTAINER': 'bold dodger_blue1',
+        'DATASET': 'bold orange3',
+        'FILE': 'bold default',
+        'COLLECTION': 'bold green',
+        'ALL': 'bold magenta',
+        'DERIVED': 'bold magenta'
+    }
+
+    BOOLEAN = {
+        'True': 'green',
+        'False': 'red'
+    }
+
+    RULE_STATE = {
+        'OK': 'bold green',
+        'REPLICATING': 'bold default',
+        'STUCK': 'bold orange3',
+        'WAITING APPROVAL': 'bold dodger_blue1',
+        'INJECT': 'bold medium_purple3',
+        'SUSPENDED': 'bold red'
+    }
+
+    RSE_TYPE = {
+        'DISK': 'bold dodger_blue1',
+        'TAPE': 'bold orange3',
+        'UNKNOWN': 'bold'
+    }
+
+    SUBSCRIPTION_STATE = {
+        'ACTIVE': 'bold green',
+        'INACTIVE': 'bold',
+        'NEW': 'bold dodger_blue1',
+        'UPDATED': 'bold green',
+        'BROKEN': 'bold red',
+        'UNKNOWN': 'bold orange3'
+    }
+
+    AVAILABILITY = {
+        'AVAILABLE': 'bold green',
+        'DELETED': 'bold',
+        'LOST': 'bold red',
+        'UNKNOWN': 'bold orange3'
+    }
+
+    ACCOUNT_STATUS = {
+        'ACTIVE': 'bold green',
+        'SUSPENDED': 'bold red',
+        'DELETED': 'bold'
+    }
+
+    REPLICA_STATE = {
+        'A': 'bold green',
+        'U': 'bold red',
+        'C': 'bold default',
+        'B': 'bold dodger_blue1',
+        'D': 'bold red',
+        'T': 'bold orange3'
+    }
+
+    ACCOUNT_TYPE = {
+        'USER': 'default',
+        'GROUP': 'medium_purple3',
+        'SERVICE': 'yellow'
+    }
+
+
+def setup_rich_logger(
+    module_name: Optional[str] = None,
+    logger_name: Optional[str] = None,
+    logger_level: Optional[int] = None,
+    verbose: bool = False,
+    console: Optional[Console] = None
+) -> logging.Logger:
+    """
+    Factory method to set logger with RichHandler.
+
+    The function is a copy of the method in rucio.common.utils setup_logger() with minor changes.
+
+    :param module_name: __name__ of the module that is calling this method
+    :param logger_name: name of the logger, typically name of the module.
+    :param logger_level: if not given, fetched from config.
+    :param verbose: verbose option set in bin/rucio
+    :param console: Rich console object
+    :returns: logger with RichHandler
+    """
+    # Helper method for cfg check.
+    def _force_cfg_log_level(cfg_option: str) -> bool:
+        cfg_forced_modules = config_get('logging', cfg_option, raise_exception=False, default=None, clean_cached=True, check_config_table=False)
+        if cfg_forced_modules and module_name is not None:
+            if re.match(str(cfg_forced_modules), module_name):
+                return True
+        return False
+
+    if not logger_name:
+        if not module_name:
+            logger_name = 'user'
+        else:
+            logger_name = module_name.split('.')[-1]
+    logger = logging.getLogger(logger_name)
+
+    # Extracting the log level.
+    if not logger_level:
+        logger_level = logging.INFO
+        if verbose:
+            logger_level = logging.DEBUG
+
+        # Overriding by the config.
+        cfg_levels = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR)
+        for level in cfg_levels:
+            cfg_opt = 'forceloglevel' + logging.getLevelName(level)
+            if _force_cfg_log_level(cfg_opt):
+                logger_level = level
+
+    logger.setLevel(logger_level)
+
+    def add_handler(logger: logging.Logger,
+                    console: Optional[Console] = None,
+                    verbose: bool = False) -> None:
+
+        def time_formatter(timestamp: datetime) -> Text:
+            return Text(f"[{timestamp.isoformat(sep=' ', timespec='milliseconds')}]")
+
+        console = console or Console()
+        handler = RichHandler(rich_tracebacks=True, markup=True, show_path=verbose, show_time=verbose, console=console, tracebacks_width=min(console.width, MAX_TRACEBACK_WIDTH),
+                              tracebacks_word_wrap=True, log_time_format=time_formatter)
+        logger.addHandler(handler)
+
+    # Setting handler and formatter.
+    if not logger.handlers:
+        add_handler(logger, console, verbose)
+
+    return logger
+
+
+def _format_value(value: Optional[Union[RenderableType, int, float, bool, datetime]] = None) -> RenderableType:
+    """
+    Formats the value based on its type for Rich Table.
+
+    A helper function to format the value to Rich RenderableType.
+
+    :param value: value to format
+    :returns: formatted value
+    """
+    if value is None or str(value) == 'None':
+        return ''
+    if isinstance(value, bool):
+        return CLITheme.BOOLEAN[str(value)]
+    if isinstance(value, (int, float, datetime)):
+        return str(value)
+    return value
+
+
+def generate_table(
+    rows: 'Sequence[Sequence[Union[RenderableType, int, float, bool, datetime]]]',
+    headers: Optional['Sequence[RenderableType]'] = None,
+    row_styles: Optional['Sequence[StyleType]'] = None,
+    col_alignments: Optional[list[JustifyMethod]] = None,
+    table_format: box.Box = CLITheme.TABLE_FMT,
+) -> Table:
+    """
+    Generates a Rich Table object from given input rows.
+
+    The elements in each row can be either plain strings or Rich renderable objects.
+    Passing strings will display them as simple text, while using Rich objects
+    allows you to introduce additional structure, styling, and widgets (e.g. Text, Trees) into
+    the table. Strings with style markup will be rendered as styled text.
+
+    :param table_format: style of the table
+    :param headers: list of headers
+    :param rows: list of rows
+    :param col_alignments: list of column alignments
+    :param row_styles: list of row styles
+    :returns: a Rich Table object
+    """
+    table = Table(box=table_format, show_header=headers is not None and len(headers) > 0)
+    table.row_styles = row_styles or ['none', 'dim']
+
+    if len(rows) == 0:
+        if headers:
+            for header in headers:
+                table.add_column(header)
+        return table
+
+    # Auto-detect on first row, numerical values on the right.
+    col_alignments = col_alignments or ['right' if str(col).isnumeric() else 'left' for col in rows[0]]
+    headers = headers or [''] * len(rows[0])
+    while len(headers) > len(col_alignments):
+        col_alignments.append('left')
+
+    for header, alignment in zip(headers, col_alignments):
+        table.add_column(header, overflow='fold', justify=alignment)
+
+    for row in rows:
+        row = [_format_value(col) for col in row]
+        table.add_row(*row)
+    return table
+
+
+def print_output(
+    *output: Any,
+    console: Console,
+    no_pager: bool = False
+) -> None:
+    """
+    Prints the objects using the specified Rich console object. Optionally disables the pager if specified.
+
+    The function works similarly to Rich's `console.print()` method but provides additional control over the pager feature.
+
+    :param output: objects to print to the terminal
+    :param console: Rich console object
+    :param no_pager: flag to disable the pager
+    """
+    if console.is_terminal:
+        if no_pager:
+            console.print(*output)
+        else:
+            console.width = sys.maxsize   # Overwrite auto-detected console width.
+            console.begin_capture()
+            console.print(*output)
+    else:
+        console.width = sys.maxsize
+        console.print(*output)
+
+
+def get_cli_config() -> str:
+    """
+    Returns the CLI type from the config file.
+
+    :returns: CLI type (Rich or tabulate)
+    """
+    cli_type = config_get('experimental', 'cli', raise_exception=False, default='tabulate').lower()
+    if cli_type not in ['rich', 'tabulate']:
+        cli_type = 'tabulate'
+    return cli_type
+
+
+def get_pager() -> 'Callable[[str], None]':
+    """
+    Returns the pager function based on the terminal availability.
+
+    :returns: pager
+    """
+    default_pager = 'less'
+    try:
+        result = subprocess.run([default_pager], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        less_available = result.returncode == 0
+    except Exception:
+        less_available = False
+
+    def less_pager_function(text: str) -> None:
+        """Use the 'less' pager with -FRSXKM options."""
+        pydoc.pipepager(text, f'{default_pager} -FRSXKM')
+
+    if less_available:
+        return less_pager_function
+    return pydoc.pager

{rucio_clients-35.5.0 → rucio_clients-36.0.0}/lib/rucio/client/rseclient.py

@@ -24,7 +24,7 @@ from rucio.common.utils import build_url
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator
 
-    from rucio.common.constants import RSE_SUPPORTED_PROTOCOL_DOMAINS_LITERAL, RSE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL, SUPPORTED_PROTOCOLS_LITERAL
+    from rucio.common.constants import RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL, RSE_SUPPORTED_PROTOCOL_DOMAINS_LITERAL, SUPPORTED_PROTOCOLS_LITERAL
 
 
 class RSEClient(BaseClient):
@@ -238,7 +238,7 @@ class RSEClient(BaseClient):
             self,
             rse: str,
             protocol_domain: "RSE_SUPPORTED_PROTOCOL_DOMAINS_LITERAL" = 'ALL',
-            operation: Optional["RSE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL"] = None,
+            operation: Optional["RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL"] = None,
             default: bool = False,
             scheme: Optional['SUPPORTED_PROTOCOLS_LITERAL'] = None
     ) -> Any:
@@ -287,7 +287,7 @@ class RSEClient(BaseClient):
             rse: str,
             lfns: 'Iterable[str]',
             protocol_domain: 'RSE_SUPPORTED_PROTOCOL_DOMAINS_LITERAL' = 'ALL',
-            operation: Optional['RSE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL'] = None,
+            operation: Optional['RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL'] = None,
             scheme: Optional['SUPPORTED_PROTOCOLS_LITERAL'] = None
     ) -> dict[str, str]:
         """
@@ -409,7 +409,7 @@ class RSEClient(BaseClient):
             self,
             rse: str,
             domain: 'RSE_SUPPORTED_PROTOCOL_DOMAINS_LITERAL',
-            operation: 'RSE_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL',
+            operation: 'RSE_ALL_SUPPORTED_PROTOCOL_OPERATIONS_LITERAL',
             scheme_a: 'SUPPORTED_PROTOCOLS_LITERAL',
             scheme_b: 'SUPPORTED_PROTOCOLS_LITERAL'
     ) -> bool: