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

rucio/rse/translation.py

@@ -0,0 +1,260 @@
+# 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 hashlib
+import importlib
+import logging
+from configparser import NoOptionError, NoSectionError
+from typing import TYPE_CHECKING, Any, Optional
+
+from rucio.common import config
+from rucio.common.constants import RseAttr
+from rucio.common.exception import ConfigNotFound
+from rucio.common.plugins import PolicyPackageAlgorithms
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from rucio.common.types import RSESettingsDict
+
+
+class RSEDeterministicScopeTranslation(PolicyPackageAlgorithms):
+    """
+        Translates a pfn dictionary into a scope and name
+    """
+
+    _algorithm_type = "pfn2lfn"
+
+    def __init__(self, vo: str = 'def'):
+        super().__init__()
+
+        logger = logging.getLogger(__name__)
+
+        try:
+            algorithm_name = config.config_get('policy', self._algorithm_type)
+        except (ConfigNotFound, NoOptionError, NoSectionError, RuntimeError):
+            logger.debug("PFN2LFN: no algorithm specified in the config.")
+            if super()._supports(self._algorithm_type, vo):
+                algorithm_name = vo
+            else:
+                algorithm_name = "def"
+            logger.debug("PFN2LFN: Falling back to %s algorithm.", 'default' if algorithm_name == 'def' else algorithm_name)
+
+        self.parser = self.get_parser(algorithm_name)
+
+    @classmethod
+    def _module_init_(cls) -> None:
+        """
+        Registers the included scope extraction algorithms
+        """
+        cls.register(cls._default, "def")
+
+    @classmethod
+    def get_parser(cls, algorithm_name: str) -> 'Callable[..., Any]':
+        return super()._get_one_algorithm(cls._algorithm_type, algorithm_name)
+
+    @classmethod
+    def register(
+        cls,
+        pfn2lfn_callable: 'Callable',
+        name: Optional[str] = None
+    ) -> None:
+        """
+        Provided a callable function, register it as one of the valid PFN2LFN algorithms.
+
+
+        :param pfn2lfn_callable: Callable function to use.
+        :param name: Algorithm name used for registration.
+        """
+        if name is None:
+            name = pfn2lfn_callable.__name__
+        algorithm_dict = {name: pfn2lfn_callable}
+        super()._register(cls._algorithm_type, algorithm_dict)
+
+    @staticmethod
+    def _default(parsed_pfn: 'Mapping[str, str]') -> tuple[str, str]:
+        """ Translate pfn to name/scope pair
+
+        :param parsed_pfn: dictionary representing pfn containing:
+            - path: str,
+            - name: str
+        :return: tuple containing name, scope
+        """
+        path = parsed_pfn['path']
+        scope = path.lstrip('/').split('/')[0]
+        name = parsed_pfn['name']
+        return name, scope
+
+
+RSEDeterministicScopeTranslation._module_init_()  # pylint: disable=protected-access
+
+
+class RSEDeterministicTranslation(PolicyPackageAlgorithms):
+    """
+    Execute the logic for translating a LFN to a path.
+    """
+
+    _DEFAULT_LFN2PFN = "hash"
+    _algorithm_type = "lfn2pfn"
+
+    def __init__(
+            self,
+            rse: Optional[str] = None,
+            rse_attributes: Optional["RSESettingsDict"] = None,
+            protocol_attributes: Optional[dict[str, Any]] = None
+    ):
+        """
+        Initialize a translator object from the RSE, its attributes, and the protocol-specific
+        attributes.
+
+        :param rse: Name of RSE for this translation.
+        :param rse_attributes: A dictionary of RSE-specific attributes for use in the translation.
+        :param protocol_attributes: A dictionary of RSE/protocol-specific attributes.
+        """
+        super().__init__()
+        self.rse = rse
+        self.rse_attributes = rse_attributes if rse_attributes else {}
+        self.protocol_attributes = protocol_attributes if protocol_attributes else {}
+
+    @classmethod
+    def supports(
+        cls,
+        name: str
+    ) -> bool:
+        """
+        Check to see if a specific algorithm is supported.
+
+        :param name: Name of the deterministic algorithm.
+        :returns: True if `name` is an algorithm supported by the translator class, False otherwise
+        """
+        return super()._supports(cls._algorithm_type, name)
+
+    @classmethod
+    def register(
+        cls,
+        lfn2pfn_callable: 'Callable',
+        name: Optional[str] = None
+    ) -> None:
+        """
+        Provided a callable function, register it as one of the valid LFN2PFN algorithms.
+
+        The callable will receive five arguments:
+         - scope: Scope of the LFN.
+         - name: LFN's path name
+         - rse: RSE name the translation is being done for.
+         - rse_attributes: Attributes of the RSE.
+         - protocol_attributes: Attributes of the RSE's protocol
+        The return value should be the last part of the PFN - it will be appended to the
+        rest of the URL.
+
+        :param lfn2pfn_callable: Callable function to use for generating paths.
+        :param name: Algorithm name used for registration.  If None, then `lfn2pfn_callable.__name__` is used.
+        """
+        if name is None:
+            name = lfn2pfn_callable.__name__
+        algorithm_dict = {name: lfn2pfn_callable}
+        super()._register(cls._algorithm_type, algorithm_dict)
+
+    @staticmethod
+    def __hash(
+        scope: str,
+        name: str,
+        rse: str,
+        rse_attrs: dict[str, Any],
+        protocol_attrs: dict[str, Any]
+    ) -> str:
+        """
+        Given a LFN, turn it into a sub-directory structure using a hash function.
+
+        This takes the MD5 of the LFN and uses the first four characters as a subdirectory
+        name.
+
+        :param scope: Scope of the LFN.
+        :param name: File name of the LFN.
+        :param rse: RSE for PFN (ignored)
+        :param rse_attrs: RSE attributes for PFN (ignored)
+        :param protocol_attrs: RSE protocol attributes for PFN (ignored)
+        :returns: Path for use in the PFN generation.
+        """
+        del rse
+        del rse_attrs
+        del protocol_attrs
+        hstr = hashlib.md5(('%s:%s' % (scope, name)).encode('utf-8')).hexdigest()
+        if scope.startswith('user') or scope.startswith('group'):
+            scope = scope.replace('.', '/')
+        return '%s/%s/%s/%s' % (scope, hstr[0:2], hstr[2:4], name)
+
+    @staticmethod
+    def __identity(
+        scope: str,
+        name: str,
+        rse: str,
+        rse_attrs: dict[str, Any],
+        protocol_attrs: dict[str, Any]
+    ) -> str:
+        """
+        Given a LFN, convert it directly to a path using the mapping:
+
+            scope:path -> scope/path
+
+        :param scope: Scope of the LFN.
+        :param name: File name of the LFN.
+        :param rse: RSE for PFN (ignored)
+        :param rse_attrs: RSE attributes for PFN (ignored)
+        :param protocol_attrs: RSE protocol attributes for PFN (ignored)
+        :returns: Path for use in the PFN generation.
+        """
+        del rse
+        del rse_attrs
+        del protocol_attrs
+        if scope.startswith('user') or scope.startswith('group'):
+            scope = scope.replace('.', '/')
+        return '%s/%s' % (scope, name)
+
+    @classmethod
+    def _module_init_(cls) -> None:
+        """
+        Initialize the class object on first module load.
+        """
+        cls.register(cls.__hash, "hash")
+        cls.register(cls.__identity, "identity")
+        policy_module = None
+        try:
+            policy_module = config.config_get('policy', 'lfn2pfn_module')
+        except (ConfigNotFound, NoOptionError, NoSectionError):
+            pass
+        if policy_module:
+            importlib.import_module(policy_module)
+
+        cls._DEFAULT_LFN2PFN = config.get_lfn2pfn_algorithm_default()
+
+    def path(
+            self,
+            scope: str,
+            name: str
+    ) -> str:
+        """ Transforms the logical file name into a PFN's path.
+
+            :param lfn: filename
+            :param scope: scope
+
+            :returns: RSE specific URI of the physical file
+        """
+        algorithm = self.rse_attributes.get(RseAttr.LFN2PFN_ALGORITHM, 'default')
+        if algorithm == 'default':
+            algorithm = RSEDeterministicTranslation._DEFAULT_LFN2PFN
+        algorithm_callable = super()._get_one_algorithm(RSEDeterministicTranslation._algorithm_type, algorithm)
+        return algorithm_callable(scope, name, self.rse, self.rse_attributes, self.protocol_attributes)
+
+
+RSEDeterministicTranslation._module_init_()  # pylint: disable=protected-access

rucio/vcsversion.py

@@ -4,8 +4,8 @@ This file is automatically generated; Do not edit it. :)
 '''
 VERSION_INFO = {
     'final': True,
-    'version': '35.7.0',
-    'branch_nick': 'release-35-LTS',
-    'revision_id': 'c96dca5cf90ca93cb024f30f987ed8c48815a64d',
-    'revno': 13202
+    'version': '37.0.0',
+    'branch_nick': 'master',
+    'revision_id': '4618b6bc894b3f8554115a6ff58bea415295ff8e',
+    'revno': 13616
 }

rucio/version.py

@@ -35,4 +35,11 @@ def vcs_version_string() -> str:
 
 def version_string_with_vcs() -> str:
     """ Get the version string with VCS """
+
     return "%s-%s" % (canonical_version_string(), vcs_version_string())
+
+
+def current_version() -> str:
+    """ Get the current version """
+    components = 2 if version_string().startswith("1.") else 1
+    return ".".join(version_string().split(".")[:components])

{rucio_clients-35.7.0.data → rucio_clients-37.0.0.data}/data/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.7.0.data → rucio_clients-37.0.0.data}/data/etc/rucio.cfg.template

@@ -77,7 +77,7 @@ default = sqlite:////tmp/rucio.db
 #default = oracle://_____________:___________@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=______))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=_____________)))
 #schema=atlas_rucio  # only for cern oracle
 #default = mysql+pymysql://rucio:rucio@localhost/rucio
-#default = postgresql://rucio:rucio@localhost/rucio
+#default = postgresql+psycopg://rucio:rucio@localhost/rucio
 pool_recycle=3600
 echo=0
 pool_reset_on_return=rollback
@@ -211,27 +211,11 @@ fts_servers = https://fts3-pilot.cern.ch:8446, https://fts3-devel.cern.ch:8446,
 cache = /opt/rucio/auditor-cache
 results = /opt/rucio/auditor-results
 
-[c3po]
-placement_algorithm = t2_free_space
-elastic_url = http://aianalytics01.cern.ch:9200
-redis_host = localhost
-redis_port = 6379
-
-[c3po-popularity]
-elastic_url = http://rucio-logger-prod-01.cern.ch:9200
-
-[c3po-site-mapper]
-panda_url = http://atlas-agis-api.cern.ch/request/pandaqueue/query/list/?json
-ddm_url = http://atlas-agis-api.cern.ch/request/ddmendpoint/query/list/?json
-
-[c3po-workload]
-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.7.0.data → rucio_clients-37.0.0.data}/data/requirements.client.txt

@@ -1,15 +1,19 @@
 # All dependencies needed to run rucio client should be defined here
-requests>=2.32.2                                            # Python HTTP for Humans.
-urllib3>=1.26.18                                            # HTTP library with thread-safe connection pooling, file post, etc.
+requests>=2.32.3                                            # Python HTTP for Humans.
+urllib3>=2.3.0                                              # HTTP library with thread-safe connection pooling, file post, etc.
 dogpile-cache>=1.2.2                                        # Caching API plugins (1.1.2 is the first version to support pymemcache)
 tabulate>=0.9.0                                             # Pretty-print tabular data
-jsonschema>=4.20.0                                          # For JSON schema validation (Policy modules)
+jsonschema>=4.23.0                                          # For JSON schema validation (Policy modules)
+packaging>=24.2                                             # Packaging utilities
+rich>=13.9.4                                                # For Rich terminal display
+typing-extensions>=4.12.2                                   # Type annotations that are not yet supported in the `typing` module
+click>=8.1.7                                                # CLI engine
 
 # All dependencies needed in extras for rucio client should be defined here
-paramiko>=3.4.1                                             # ssh_extras; SSH2 protocol library (also needed in the server)
+paramiko>=3.5.1                                             # ssh_extras; SSH2 protocol library (also needed in the server)
 kerberos>=1.3.1                                             # kerberos_extras for client and server
 pykerberos>=1.2.4                                           # kerberos_extras for client and server
-requests-kerberos>=0.14.0                                   # kerberos_extras for client and server
-python-swiftclient>=4.4.0                                   # swift_extras
-argcomplete>=3.1.6                                          # argcomplete_extras; Bash tab completion for argparse
+requests-kerberos>=0.15.0                                   # kerberos_extras for client and server
+python-swiftclient>=4.7.0                                   # swift_extras
+argcomplete>=3.5.3                                          # argcomplete_extras; Bash tab completion for argparse
 python-magic>=0.4.27                                        # dumper_extras; File type identification using libmagic

rucio_clients-37.0.0.data/scripts/rucio

@@ -0,0 +1,133 @@
+#!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 TYPE_CHECKING, Optional
+
+from rucio.cli.bin_legacy.rucio import main as main_legacy
+from rucio.cli.command import main
+from rucio.common.utils import setup_logger
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+
+def _get_first_command(args: list[str]) -> Optional[str]:
+    return next(
+        (
+            arg for arg in args
+            if arg != 'rucio' and (arg[0] != "-" or arg in ("-h", "--help", "--version"))
+        ),
+        None
+    )
+
+
+def make_warning(logger: "Logger") -> None:
+    base_warning = "This method is being deprecated."
+    new_command = map_legacy_command()
+    if new_command is not None:
+        warning = f"{base_warning} Please replace your command with `rucio {' '.join(new_command)}`"
+    else:
+        warning = base_warning + " Please view rucio -h for an updated help menu."
+
+    logger.warning(warning)
+
+
+def map_legacy_command() -> Optional[list[str]]:
+    command = _get_first_command(sys.argv[1:])
+
+    new_command = None
+    if command not in ("-h", "--version", None):
+        command_map = {
+            "list-file-replicas": ["replica", "list", "file"],
+            "list-dataset-replicas": ["replica", "list", "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", "list", "--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", "limit", "list"],
+            "list-account-limits": ["account", "limit", "list"],
+            "add-rule": ["rule", "add"],
+            "delete-rule": ["rule", "remove"],
+            "rule-info": ["rule", "show"],
+            "list-rules": ["rule", "list"],
+            "list-rules-history": ["rule", "history"],
+            "update-rule": ["rule", "update"],
+            "move-rule": ["rule", "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"],
+        }
+        new_command = command_map.get(command)
+
+    return new_command
+
+
+if __name__ == "__main__":
+    commands = ("account", "config", "did", "replica", "rse", "rule", "scope", "subscription", "ping", "whoami", "test-server", "lifetime-exception", "upload", "download")
+
+    parser = argparse.ArgumentParser(add_help=False)
+    # Check for legacy flag
+    parser.add_argument("--legacy", action="store_true")
+    # Check for commands in the new command list
+    parser.add_argument("-h", "--help", action="store_true")
+    parser.add_argument("--version", action="store_true")
+
+    args, _ = parser.parse_known_args()
+
+    logger = setup_logger(module_name=__name__)
+
+    if args.legacy:
+        make_warning(logger)
+        sys.argv.pop(sys.argv.index('--legacy'))
+        main_legacy()
+
+    elif (any(arg in commands for arg in sys.argv)) or args.help or args.version:
+        main()  # pylint: disable=E1120
+
+    else:
+        make_warning(logger)
+        try:
+            main_legacy()
+        # Make a custom warning - show the new help menu when invalid commands are called.
+        except argparse.ArgumentError:
+            logger.error("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()  # pylint: disable=E1120

rucio_clients-37.0.0.data/scripts/rucio-admin

@@ -0,0 +1,97 @@
+#!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.cli.bin_legacy.rucio_admin import main as main_legacy
+from rucio.common.utils import setup_logger
+
+
+def make_warning():
+    logger = setup_logger(module_name=__name__)
+
+    base_warning = "This method is being deprecated."
+    args = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--help", "--version")]
+    try:
+        first_command = args[1]
+    except IndexError:
+        first_command = None
+    try:
+        second_command = args[2]
+    except IndexError:
+        second_command = "-h"
+
+    if (first_command not in ("-h", "--version", "--help")) and (first_command is not None):
+        command_map = {
+            "data": {"import": "upload", "export": "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",
+                "unban": "account update --unban",
+                "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 list",
+                "update": "rse update",
+                "info": "rse show",
+                "set-attribute": "rse attribute add",
+                "delete-attribute": "rse attribute remove",
+                "delete-distance": "rse distance remove",
+                "get-distance": "rse distance show",
+                "set-distance": "rse distance update",
+                "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 update quarantine", "declare-bad": "replica state update bad", "declare-temporary-unavailable": "replica state update unavailable", "set-tombstone": "replica remove"},
+        }
+        try:
+            new_command = command_map[first_command]
+            new_command = new_command[second_command]
+        except KeyError:
+            new_command = "-h"
+
+        warning = f"{base_warning} Please replace your command with `rucio {new_command}`"
+    else:
+        warning = base_warning + " Please view rucio -h for an updated help menu."
+
+    logger.warning(warning)
+
+
+if __name__ == "__main__":
+    make_warning()
+    main_legacy()

{rucio_clients-35.7.0.dist-info → rucio_clients-37.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rucio-clients
-Version: 35.7.0
+Version: 37.0.0
 Summary: Rucio Client Lite Package
 Home-page: https://rucio.cern.ch/
 Author: Rucio
@@ -19,25 +19,29 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.9, <4
 License-File: LICENSE
 License-File: AUTHORS.rst
-Requires-Dist: requests>=2.32.2
-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: requests
+Requires-Dist: urllib3
+Requires-Dist: dogpile-cache<=1.2.2
+Requires-Dist: packaging
+Requires-Dist: tabulate
+Requires-Dist: jsonschema
+Requires-Dist: dataclasses
+Requires-Dist: rich
+Requires-Dist: typing_extensions
 Provides-Extra: ssh
-Requires-Dist: paramiko>=3.4.1; extra == "ssh"
+Requires-Dist: paramiko; extra == "ssh"
 Provides-Extra: kerberos
-Requires-Dist: kerberos>=1.3.1; extra == "kerberos"
-Requires-Dist: pykerberos>=1.2.4; extra == "kerberos"
-Requires-Dist: requests-kerberos>=0.14.0; extra == "kerberos"
+Requires-Dist: kerberos; extra == "kerberos"
+Requires-Dist: pykerberos; extra == "kerberos"
+Requires-Dist: requests-kerberos; extra == "kerberos"
 Provides-Extra: swift
-Requires-Dist: python-swiftclient>=4.4.0; extra == "swift"
+Requires-Dist: python-swiftclient; extra == "swift"
 Provides-Extra: argcomplete
-Requires-Dist: argcomplete>=3.1.6; extra == "argcomplete"
+Requires-Dist: argcomplete; extra == "argcomplete"
 Provides-Extra: sftp
-Requires-Dist: paramiko>=3.4.1; extra == "sftp"
+Requires-Dist: paramiko; extra == "sftp"
 Provides-Extra: dumper
-Requires-Dist: python-magic>=0.4.27; extra == "dumper"
+Requires-Dist: python-magic; extra == "dumper"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier