skypilot-nightly 1.0.0.dev20250331__py3-none-any.whl → 1.0.0.dev20250402__py3-none-any.whl

sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = 'f90ccc1757680ccbff2fb8d86fc6dfd4242bd182'
+_SKYPILOT_COMMIT_SHA = '515e5df7c14cfd425f606de20d4b96d6a897ee7d'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250331'
+__version__ = '1.0.0.dev20250402'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

sky/adaptors/kubernetes.py

@@ -146,6 +146,13 @@ def apps_api(context: Optional[str] = None):
     return kubernetes.client.AppsV1Api()
 
 
+@_api_logging_decorator('urllib3', logging.ERROR)
+@annotations.lru_cache(scope='request')
+def batch_api(context: Optional[str] = None):
+    _load_config(context)
+    return kubernetes.client.BatchV1Api()
+
+
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
 def api_client(context: Optional[str] = None):

sky/backends/cloud_vm_ray_backend.py

@@ -61,6 +61,7 @@ from sky.utils import command_runner
 from sky.utils import common
 from sky.utils import common_utils
 from sky.utils import controller_utils
+from sky.utils import env_options
 from sky.utils import log_utils
 from sky.utils import message_utils
 from sky.utils import registry
@@ -622,13 +623,39 @@ class RayCodeGen:
         options_str = ', '.join(options)
         logger.debug('Added Task with options: '
                      f'{options_str}')
+        # Script to block completion of a job until all storage mounted with
+        # CACHED_MOUNT mode is uploaded to remote.
+        rclone_flush_script = textwrap.dedent(f"""\
+
+        if [ $(findmnt -t fuse.rclone --noheading | wc -l) -gt 0 ]; then
+            flushed=0
+            # extra second on top of --vfs-cache-poll-interval to
+            # avoid race condition between rclone log line creation and this check.
+            sleep 1
+            while [ $flushed -eq 0 ]; do
+                # sleep for the same interval as --vfs-cache-poll-interval
+                sleep {constants.RCLONE_CACHE_REFRESH_INTERVAL}
+                flushed=1
+                for file in {constants.RCLONE_LOG_DIR}/*; do
+                    exitcode=0
+                    tac $file | grep "vfs cache: cleaned:" -m 1 | grep "in use 0, to upload 0, uploading 0" -q || exitcode=$?
+                    if [ $exitcode -ne 0 ]; then
+                        echo "skypilot: cached mount is still uploading to remote"
+                        flushed=0
+                        break
+                    fi
+                done
+            done
+            echo "skypilot: cached mount uploaded complete"
+        fi""")
         self._code += [
             sky_env_vars_dict_str,
             textwrap.dedent(f"""\
         script = {bash_script!r}
+        rclone_flush_script = {rclone_flush_script!r}
         if run_fn is not None:
             script = run_fn({gang_scheduling_id}, gang_scheduling_id_to_ip)
-
+        script += rclone_flush_script
 
         if script is not None:
             sky_env_vars_dict['{constants.SKYPILOT_NUM_GPUS_PER_NODE}'] = {int(math.ceil(num_gpus))!r}
@@ -4869,7 +4896,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
         # Handle cases where `storage_mounts` is None. This occurs when users
         # initiate a 'sky start' command from a Skypilot version that predates
         # the introduction of the `storage_mounts_metadata` feature.
-        if not storage_mounts:
+        if storage_mounts is None:
             return
 
         # Process only mount mode objects here. COPY mode objects have been
@@ -4878,10 +4905,11 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
         storage_mounts = {
             path: storage_mount
             for path, storage_mount in storage_mounts.items()
-            if storage_mount.mode == storage_lib.StorageMode.MOUNT
+            if storage_mount.mode in storage_lib.MOUNTABLE_STORAGE_MODES
         }
 
-        # Handle cases when there aren't any Storages with MOUNT mode.
+        # Handle cases when there aren't any Storages with either MOUNT or
+        # MOUNT_CACHED mode.
         if not storage_mounts:
             return
         start = time.time()
@@ -4911,7 +4939,13 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
             # Get the first store and use it to mount
             store = list(storage_obj.stores.values())[0]
             assert store is not None, storage_obj
-            mount_cmd = store.mount_command(dst)
+            if storage_obj.mode == storage_lib.StorageMode.MOUNT:
+                mount_cmd = store.mount_command(dst)
+                action_message = 'Mounting'
+            else:
+                assert storage_obj.mode == storage_lib.StorageMode.MOUNT_CACHED
+                mount_cmd = store.mount_cached_command(dst)
+                action_message = 'Mounting cached mode'
             src_print = (storage_obj.source
                          if storage_obj.source else storage_obj.name)
             if isinstance(src_print, list):
@@ -4923,7 +4957,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
                     target=dst,
                     cmd=mount_cmd,
                     run_rsync=False,
-                    action_message='Mounting',
+                    action_message=action_message,
                     log_path=log_path,
                     # Need to source bashrc, as the cloud specific CLI or SDK
                     # may require PATH in bashrc.
@@ -4942,12 +4976,23 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
                                  f' to an empty or non-existent path.')
                     raise RuntimeError(error_msg) from None
                 else:
-                    # Strip the command (a big heredoc) from the exception
-                    raise exceptions.CommandError(
-                        e.returncode,
-                        command='to mount',
-                        error_msg=e.error_msg,
-                        detailed_reason=e.detailed_reason) from None
+                    # By default, raising an error caused from mounting_utils
+                    # shows a big heredoc as part of it. Here, we want to
+                    # conditionally show the heredoc only if SKYPILOT_DEBUG
+                    # is set
+                    if env_options.Options.SHOW_DEBUG_INFO.get():
+                        raise exceptions.CommandError(
+                            e.returncode,
+                            command='to mount',
+                            error_msg=e.error_msg,
+                            detailed_reason=e.detailed_reason)
+                    else:
+                        # Strip the command (a big heredoc) from the exception
+                        raise exceptions.CommandError(
+                            e.returncode,
+                            command='to mount',
+                            error_msg=e.error_msg,
+                            detailed_reason=e.detailed_reason) from None
 
         end = time.time()
         logger.debug(f'Storage mount sync took {end - start} seconds.')
@@ -4965,7 +5010,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
             return
         storage_mounts_metadata = {}
         for dst, storage_obj in storage_mounts.items():
-            if storage_obj.mode != storage_lib.StorageMode.MOUNT:
+            if storage_obj.mode not in storage_lib.MOUNTABLE_STORAGE_MODES:
                 # Skip non-mount storage objects, as there is no need to
                 # reconstruct them during cluster restart.
                 continue

sky/check.py

@@ -359,9 +359,9 @@ def _format_enabled_cloud(cloud_name: str,
                           if i == len(existing_contexts) -
                           1 else ux_utils.INDENT_SYMBOL)
                 contexts_formatted.append(f'\n    {symbol}{context}')
-            context_info = f'Allowed contexts:{"".join(contexts_formatted)}'
+            context_info = f'  Allowed contexts:{"".join(contexts_formatted)}'
         else:
-            context_info = f'Active context: {existing_contexts[0]}'
+            context_info = f'  Active context: {existing_contexts[0]}'
 
         return (f'{_green_color(cloud_and_capabilities)}\n'
                 f'  {colorama.Style.DIM}{context_info}'

sky/cli.py

@@ -253,7 +253,8 @@ def _async_call_or_wait(request_id: str, async_call: bool,
                     fg='green')
         click.echo(
             f'{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Check logs with: '
-            f'sky api logs {short_request_id}{colorama.Style.RESET_ALL}\n'
+            f'{ux_utils.BOLD}sky api logs {short_request_id}'
+            f'{colorama.Style.RESET_ALL}\n'
             f'{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Or, visit: '
             f'{server_common.get_server_url()}/api/stream?'
             f'request_id={short_request_id}'
@@ -3900,8 +3901,11 @@ def jobs_launch(
 
     common_utils.check_cluster_name_is_valid(name)
 
-    click.secho(f'Managed job {dag.name!r} will be launched on (estimated):',
-                fg='yellow')
+    # Optimize info is only show if _need_confirmation.
+    if not yes:
+        click.secho(
+            f'Managed job {dag.name!r} will be launched on (estimated):',
+            fg='yellow')
 
     request_id = managed_jobs.launch(dag, name, _need_confirmation=not yes)
     job_id_handle = _async_call_or_wait(request_id, async_call,

sky/client/cli.py

@@ -253,7 +253,8 @@ def _async_call_or_wait(request_id: str, async_call: bool,
                     fg='green')
         click.echo(
             f'{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Check logs with: '
-            f'sky api logs {short_request_id}{colorama.Style.RESET_ALL}\n'
+            f'{ux_utils.BOLD}sky api logs {short_request_id}'
+            f'{colorama.Style.RESET_ALL}\n'
             f'{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Or, visit: '
             f'{server_common.get_server_url()}/api/stream?'
             f'request_id={short_request_id}'
@@ -3900,8 +3901,11 @@ def jobs_launch(
 
     common_utils.check_cluster_name_is_valid(name)
 
-    click.secho(f'Managed job {dag.name!r} will be launched on (estimated):',
-                fg='yellow')
+    # Optimize info is only show if _need_confirmation.
+    if not yes:
+        click.secho(
+            f'Managed job {dag.name!r} will be launched on (estimated):',
+            fg='yellow')
 
     request_id = managed_jobs.launch(dag, name, _need_confirmation=not yes)
     job_id_handle = _async_call_or_wait(request_id, async_call,

sky/cloud_stores.py

@@ -23,7 +23,6 @@ from sky.adaptors import nebius
 from sky.adaptors import oci
 from sky.clouds import gcp
 from sky.data import data_utils
-from sky.data.data_utils import Rclone
 from sky.skylet import constants
 from sky.utils import ux_utils
 
@@ -454,19 +453,18 @@ class IBMCosCloudStorage(CloudStorage):
     def _get_rclone_sync_command(self, source: str, destination: str):
         bucket_name, data_path, bucket_region = data_utils.split_cos_path(
             source)
-        bucket_rclone_profile = Rclone.generate_rclone_bucket_profile_name(
-            bucket_name, Rclone.RcloneClouds.IBM)
-        data_path_in_bucket = bucket_name + data_path
-        rclone_config_data = Rclone.get_rclone_config(bucket_name,
-                                                      Rclone.RcloneClouds.IBM,
-                                                      bucket_region)
+        rclone_profile_name = (
+            data_utils.Rclone.RcloneStores.IBM.get_profile_name(bucket_name))
+        data_path_in_bucket = f'{bucket_name}{data_path}'
+        rclone_config = data_utils.Rclone.RcloneStores.IBM.get_config(
+            rclone_profile_name=rclone_profile_name, region=bucket_region)
         # configure_rclone stores bucket profile in remote cluster's rclone.conf
         configure_rclone = (
-            f' mkdir -p ~/.config/rclone/ &&'
-            f' echo "{rclone_config_data}">> {Rclone.RCLONE_CONFIG_PATH}')
+            f' mkdir -p {constants.RCLONE_CONFIG_DIR} &&'
+            f' echo "{rclone_config}">> {constants.RCLONE_CONFIG_PATH}')
         download_via_rclone = (
             'rclone copy '
-            f'{bucket_rclone_profile}:{data_path_in_bucket} {destination}')
+            f'{rclone_profile_name}:{data_path_in_bucket} {destination}')
 
         all_commands = list(self._GET_RCLONE)
         all_commands.append(configure_rclone)

sky/data/data_utils.py

@@ -1,7 +1,7 @@
 """Miscellaneous Utils for Sky Data
 """
 import concurrent.futures
-from enum import Enum
+import enum
 from multiprocessing import pool
 import os
 import re
@@ -13,6 +13,7 @@ import urllib.parse
 
 from filelock import FileLock
 
+from sky import clouds
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import aws
@@ -21,6 +22,7 @@ from sky.adaptors import cloudflare
 from sky.adaptors import gcp
 from sky.adaptors import ibm
 from sky.adaptors import nebius
+from sky.skylet import constants
 from sky.skylet import log_lib
 from sky.utils import common_utils
 from sky.utils import ux_utils
@@ -589,73 +591,146 @@ def get_cos_regions() -> List[str]:
     ]
 
 
-class Rclone():
-    """Static class implementing common utilities of rclone without rclone sdk.
-
-    Storage providers supported by rclone are required to:
-    - list their rclone profile prefix in RcloneClouds
-    - implement configuration in get_rclone_config()
-    """
-
-    RCLONE_CONFIG_PATH = '~/.config/rclone/rclone.conf'
-    _RCLONE_ABS_CONFIG_PATH = os.path.expanduser(RCLONE_CONFIG_PATH)
-
-    # Mapping of storage providers using rclone
-    # to their respective profile prefix
-    class RcloneClouds(Enum):
-        IBM = 'sky-ibm-'
+class Rclone:
+    """Provides methods to manage and generate Rclone configuration profile."""
+
+    # TODO(syang) Move the enum's functionality into AbstractStore subclass and
+    # deprecate this class.
+    class RcloneStores(enum.Enum):
+        """Rclone supporting storage types and supporting methods."""
+        S3 = 'S3'
+        GCS = 'GCS'
+        IBM = 'IBM'
+        R2 = 'R2'
+        AZURE = 'AZURE'
+
+        def get_profile_name(self, bucket_name: str) -> str:
+            """Gets the Rclone profile name for a given bucket.
+
+            Args:
+                bucket_name: The name of the bucket.
+
+            Returns:
+                A string containing the Rclone profile name, which combines
+                prefix based on the storage type and the bucket name.
+            """
+            profile_prefix = {
+                Rclone.RcloneStores.S3: 'sky-s3',
+                Rclone.RcloneStores.GCS: 'sky-gcs',
+                Rclone.RcloneStores.IBM: 'sky-ibm',
+                Rclone.RcloneStores.R2: 'sky-r2',
+                Rclone.RcloneStores.AZURE: 'sky-azure'
+            }
+            return f'{profile_prefix[self]}-{bucket_name}'
+
+        def get_config(self,
+                       bucket_name: Optional[str] = None,
+                       rclone_profile_name: Optional[str] = None,
+                       region: Optional[str] = None,
+                       storage_account_name: Optional[str] = None,
+                       storage_account_key: Optional[str] = None) -> str:
+            """Generates an Rclone configuration for a specific storage type.
+
+            This method creates an Rclone configuration string based on the
+            storage type and the provided parameters.
+
+            Args:
+                bucket_name: The name of the bucket.
+                rclone_profile_name: The name of the Rclone profile. If not
+                    provided, it will be generated using the bucket_name.
+                region: Region of bucket.
+
+            Returns:
+                A string containing the Rclone configuration.
+
+            Raises:
+                NotImplementedError: If the storage type is not supported.
+            """
+            if rclone_profile_name is None:
+                assert bucket_name is not None
+                rclone_profile_name = self.get_profile_name(bucket_name)
+            if self is Rclone.RcloneStores.S3:
+                aws_credentials = (
+                    aws.session().get_credentials().get_frozen_credentials())
+                access_key_id = aws_credentials.access_key
+                secret_access_key = aws_credentials.secret_key
+                config = textwrap.dedent(f"""\
+                    [{rclone_profile_name}]
+                    type = s3
+                    provider = AWS
+                    access_key_id = {access_key_id}
+                    secret_access_key = {secret_access_key}
+                    acl = private
+                    """)
+            elif self is Rclone.RcloneStores.GCS:
+                config = textwrap.dedent(f"""\
+                    [{rclone_profile_name}]
+                    type = google cloud storage
+                    project_number = {clouds.GCP.get_project_id()}
+                    bucket_policy_only = true
+                    """)
+            elif self is Rclone.RcloneStores.IBM:
+                access_key_id, secret_access_key = ibm.get_hmac_keys()
+                config = textwrap.dedent(f"""\
+                    [{rclone_profile_name}]
+                    type = s3
+                    provider = IBMCOS
+                    access_key_id = {access_key_id}
+                    secret_access_key = {secret_access_key}
+                    region = {region}
+                    endpoint = s3.{region}.cloud-object-storage.appdomain.cloud
+                    location_constraint = {region}-smart
+                    acl = private
+                    """)
+            elif self is Rclone.RcloneStores.R2:
+                cloudflare_session = cloudflare.session()
+                cloudflare_credentials = (
+                    cloudflare.get_r2_credentials(cloudflare_session))
+                endpoint = cloudflare.create_endpoint()
+                access_key_id = cloudflare_credentials.access_key
+                secret_access_key = cloudflare_credentials.secret_key
+                config = textwrap.dedent(f"""\
+                    [{rclone_profile_name}]
+                    type = s3
+                    provider = Cloudflare
+                    access_key_id = {access_key_id}
+                    secret_access_key = {secret_access_key}
+                    endpoint = {endpoint}
+                    region = auto
+                    acl = private
+                    """)
+            elif self is Rclone.RcloneStores.AZURE:
+                assert storage_account_name and storage_account_key
+                config = textwrap.dedent(f"""\
+                    [{rclone_profile_name}]
+                    type = azureblob
+                    account = {storage_account_name}
+                    key = {storage_account_key}
+                    """)
+            else:
+                with ux_utils.print_exception_no_traceback():
+                    raise NotImplementedError(
+                        f'Unsupported store type for Rclone: {self}')
+            return config
 
     @staticmethod
-    def generate_rclone_bucket_profile_name(bucket_name: str,
-                                            cloud: RcloneClouds) -> str:
-        """Returns rclone profile name for specified bucket
+    def store_rclone_config(bucket_name: str, cloud: RcloneStores,
+                            region: str) -> str:
+        """Creates rclone configuration files for bucket syncing and mounting.
 
         Args:
-            bucket_name (str): name of bucket
-            cloud (RcloneClouds): enum object of storage provider
-                supported via rclone
-        """
-        try:
-            return cloud.value + bucket_name
-        except AttributeError as e:
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError(f'Value: {cloud} isn\'t a member of '
-                                 'Rclone.RcloneClouds') from e
-
-    @staticmethod
-    def get_rclone_config(bucket_name: str, cloud: RcloneClouds,
-                          region: str) -> str:
-        bucket_rclone_profile = Rclone.generate_rclone_bucket_profile_name(
-            bucket_name, cloud)
-        if cloud is Rclone.RcloneClouds.IBM:
-            access_key_id, secret_access_key = ibm.get_hmac_keys()
-            config_data = textwrap.dedent(f"""\
-                [{bucket_rclone_profile}]
-                type = s3
-                provider = IBMCOS
-                access_key_id = {access_key_id}
-                secret_access_key = {secret_access_key}
-                region = {region}
-                endpoint = s3.{region}.cloud-object-storage.appdomain.cloud
-                location_constraint = {region}-smart
-                acl = private
-                """)
-        else:
-            with ux_utils.print_exception_no_traceback():
-                raise NotImplementedError('No rclone configuration builder was '
-                                          f'implemented for cloud: {cloud}.')
-        return config_data
+            bucket_name: Name of the bucket.
+            cloud: RcloneStores enum representing the cloud provider.
+            region: Region of the bucket.
 
-    @staticmethod
-    def store_rclone_config(bucket_name: str, cloud: RcloneClouds,
-                            region: str) -> str:
-        """Creates a configuration files for rclone - used for
-        bucket syncing and mounting """
+        Returns:
+            str: The configuration data written to the file.
 
-        rclone_config_path = Rclone._RCLONE_ABS_CONFIG_PATH
-        config_data = Rclone.get_rclone_config(bucket_name, cloud, region)
-
-        # Raise exception if rclone isn't installed
+        Raises:
+            StorageError: If rclone is not installed.
+        """
+        rclone_config_path = os.path.expanduser(constants.RCLONE_CONFIG_PATH)
+        config_data = cloud.get_config(bucket_name=bucket_name, region=region)
         try:
             subprocess.run('rclone version',
                            shell=True,
@@ -669,9 +744,7 @@ class Rclone():
                     '"curl https://rclone.org/install.sh '
                     '| sudo bash" ') from None
 
-        # create ~/.config/rclone/ if doesn't exist
         os.makedirs(os.path.dirname(rclone_config_path), exist_ok=True)
-        # create rclone.conf if doesn't exist
         if not os.path.isfile(rclone_config_path):
             open(rclone_config_path, 'w', encoding='utf-8').close()
 
@@ -692,18 +765,24 @@ class Rclone():
         return config_data
 
     @staticmethod
-    def get_region_from_rclone(bucket_name: str, cloud: RcloneClouds) -> str:
-        """Returns region field of the specified bucket in rclone.conf
-         if bucket exists, else empty string"""
-        bucket_rclone_profile = Rclone.generate_rclone_bucket_profile_name(
-            bucket_name, cloud)
-        with open(Rclone._RCLONE_ABS_CONFIG_PATH, 'r',
-                  encoding='utf-8') as file:
+    def get_region_from_rclone(bucket_name: str, cloud: RcloneStores) -> str:
+        """Returns the region field of the specified bucket in rclone.conf.
+
+        Args:
+            bucket_name: Name of the bucket.
+            cloud: RcloneStores enum representing the cloud provider.
+
+        Returns:
+            The region field if the bucket exists, otherwise an empty string.
+        """
+        rclone_profile = cloud.get_profile_name(bucket_name)
+        rclone_config_path = os.path.expanduser(constants.RCLONE_CONFIG_PATH)
+        with open(rclone_config_path, 'r', encoding='utf-8') as file:
             bucket_profile_found = False
             for line in file:
                 if line.lstrip().startswith('#'):  # skip user's comments.
                     continue
-                if line.strip() == f'[{bucket_rclone_profile}]':
+                if line.strip() == f'[{rclone_profile}]':
                     bucket_profile_found = True
                 elif bucket_profile_found and line.startswith('region'):
                     return line.split('=')[1].strip()
@@ -715,36 +794,45 @@ class Rclone():
         return ''
 
     @staticmethod
-    def delete_rclone_bucket_profile(bucket_name: str, cloud: RcloneClouds):
-        """Deletes specified bucket profile for rclone.conf"""
-        bucket_rclone_profile = Rclone.generate_rclone_bucket_profile_name(
-            bucket_name, cloud)
-        rclone_config_path = Rclone._RCLONE_ABS_CONFIG_PATH
+    def delete_rclone_bucket_profile(bucket_name: str, cloud: RcloneStores):
+        """Deletes specified bucket profile from rclone.conf.
+
+        Args:
+            bucket_name: Name of the bucket.
+            cloud: RcloneStores enum representing the cloud provider.
+        """
+        rclone_profile = cloud.get_profile_name(bucket_name)
+        rclone_config_path = os.path.expanduser(constants.RCLONE_CONFIG_PATH)
 
         if not os.path.isfile(rclone_config_path):
-            logger.warning(
-                'Failed to locate "rclone.conf" while '
-                f'trying to delete rclone profile: {bucket_rclone_profile}')
+            logger.warning('Failed to locate "rclone.conf" while '
+                           f'trying to delete rclone profile: {rclone_profile}')
             return
 
         with FileLock(rclone_config_path + '.lock'):
             profiles_to_keep = Rclone._remove_bucket_profile_rclone(
                 bucket_name, cloud)
 
-            # write back file without profile: [bucket_rclone_profile]
+            # write back file without profile: [rclone_profile]
             with open(f'{rclone_config_path}', 'w', encoding='utf-8') as file:
                 file.writelines(profiles_to_keep)
 
     @staticmethod
     def _remove_bucket_profile_rclone(bucket_name: str,
-                                      cloud: RcloneClouds) -> List[str]:
-        """Returns rclone profiles without profiles matching
-          [profile_prefix+bucket_name]"""
-        bucket_rclone_profile = Rclone.generate_rclone_bucket_profile_name(
-            bucket_name, cloud)
-        rclone_config_path = Rclone._RCLONE_ABS_CONFIG_PATH
-
-        with open(f'{rclone_config_path}', 'r', encoding='utf-8') as file:
+                                      cloud: RcloneStores) -> List[str]:
+        """Returns rclone profiles without ones matching [prefix+bucket_name].
+
+        Args:
+            bucket_name: Name of the bucket.
+            cloud: RcloneStores enum representing the cloud provider.
+
+        Returns:
+            Lines to keep in the rclone config file.
+        """
+        rclone_profile_name = cloud.get_profile_name(bucket_name)
+        rclone_config_path = os.path.expanduser(constants.RCLONE_CONFIG_PATH)
+
+        with open(rclone_config_path, 'r', encoding='utf-8') as file:
             lines = file.readlines()  # returns a list of the file's lines
             # delete existing bucket profile matching:
             # '[profile_prefix+bucket_name]'
@@ -757,7 +845,7 @@ class Rclone():
                 # keep user comments only if they aren't under
                 # a profile we are discarding
                 lines_to_keep.append(line)
-            elif f'[{bucket_rclone_profile}]' in line:
+            elif f'[{rclone_profile_name}]' in line:
                 skip_lines = True
             elif skip_lines:
                 if '[' in line: