anyscale 0.26.50__py3-none-any.whl → 0.26.52__py3-none-any.whl

anyscale/_private/anyscale_client/README.md

@@ -87,7 +87,7 @@ Here's an example job configuration for testing:
 ```yaml
 name: generate-doggos-embeddings
 compute_config: doggos-azure:1
-working_dir: azure://cloud-dev-blob/org_7c1Kalm9WcX2bNIjW53GUT/cld_wgmfc248s6t7513awyubirlwu9/runtime_env_packages/pkg_b60e2d10615fb9845a9bad7d9307547a.zip
+working_dir: abfss://cloud-dev-blob@anyscaleclouddev.dfs.core.windows.net/org_7c1Kalm9WcX2bNIjW53GUT/cld_wgmfc248s6t7513awyubirlwu9/runtime_env_packages/pkg_b60e2d10615fb9845a9bad7d9307547a.zip
 requirements:
 - matplotlib==3.10.0
 - torch==2.7.1

anyscale/_private/anyscale_client/anyscale_client.py

@@ -67,6 +67,9 @@ from anyscale.client.openapi_client.models import (
     ListResourceQuotasQuery,
     OrganizationCollaborator,
     OrganizationInvitation,
+    Project,
+    ProjectBase,
+    ProjectListResponse,
     ResourceQuota,
     ResourceQuotaStatus,
     ServerSessionToken,
@@ -76,6 +79,7 @@ from anyscale.client.openapi_client.models import (
     StopSessionOptions,
     SystemWorkloadName,
     WorkspaceDataplaneProxiedArtifacts,
+    WriteProject,
 )
 from anyscale.client.openapi_client.models.create_schedule import CreateSchedule
 from anyscale.client.openapi_client.models.decorated_job_queue import DecoratedJobQueue
@@ -104,7 +108,7 @@ from anyscale.sdk.anyscale_client.models import (
     CreateClusterEnvironmentBuild,
     Job as APIJobRun,
     ProductionServiceV2VersionModel,
-    Project,
+    Project as ProjectExternal,
     RollbackServiceModel,
     TextQuery,
 )
@@ -158,7 +162,7 @@ def handle_api_exceptions(func):
                     body_dict = json.loads(e.body)
                     msg = body_dict["error"]["detail"]
                     raise ValueError(msg) from None
-                except KeyError:
+                except (KeyError, TypeError):
                     # ApiException doesn't conform to expected format, raise original error
                     raise e from None
             raise e from None
@@ -484,7 +488,7 @@ class AnyscaleClient(AnyscaleClientInterface):
 
         if self._default_project_id_from_cloud_id.get(parent_cloud_id) is None:
             # Cloud isolation organizations follow the permissions model in https://docs.anyscale.com/organization-and-user-account/access-controls
-            default_project: Project = self._external_api_client.get_default_project(
+            default_project: ProjectExternal = self._external_api_client.get_default_project(
                 parent_cloud_id=parent_cloud_id
             ).result
             self._default_project_id_from_cloud_id[parent_cloud_id] = default_project.id
@@ -1050,11 +1054,53 @@ class AnyscaleClient(AnyscaleClientInterface):
         )
 
     @handle_api_exceptions
-    def get_project(self, project_id: str) -> Optional[Project]:
+    def get_project(self, project_id: str) -> Project:
         return self._internal_api_client.get_project_api_v2_projects_project_id_get(
             project_id
         ).result
 
+    @handle_api_exceptions
+    def list_projects(
+        self,
+        *,
+        name_contains: Optional[str] = None,
+        creator_id: Optional[str] = None,
+        parent_cloud_id: Optional[str] = None,
+        include_defaults: bool = True,
+        sort_field: Optional[str] = None,
+        sort_order: Optional[str] = None,
+        paging_token: Optional[str] = None,
+        count: Optional[int] = None,
+    ) -> ProjectListResponse:
+        return self._internal_api_client.list_projects_api_v2_projects_get(
+            name_contains=name_contains,
+            creator_id=creator_id,
+            parent_cloud_id=parent_cloud_id,
+            include_defaults=include_defaults,
+            sort_field=sort_field,
+            sort_order=sort_order,
+            paging_token=paging_token,
+            count=count or self.LIST_ENDPOINT_COUNT,
+        )
+
+    @handle_api_exceptions
+    def create_project(self, project: WriteProject) -> ProjectBase:
+        return self._internal_api_client.create_project_api_v2_projects_post(
+            project
+        ).result
+
+    @handle_api_exceptions
+    def delete_project(self, project_id: str) -> None:
+        self._internal_api_client.delete_project_api_v2_projects_project_id_delete(
+            project_id
+        )
+
+    @handle_api_exceptions
+    def get_default_project(self, parent_cloud_id: str) -> Project:
+        return self._internal_api_client.get_default_project_api_v2_projects_default_project_get(
+            parent_cloud_id=parent_cloud_id,
+        ).result
+
     @handle_api_exceptions
     def add_project_collaborators(
         self, project_id: str, collaborators: List[CreateUserProjectCollaborator]
@@ -1243,6 +1289,64 @@ class AnyscaleClient(AnyscaleClientInterface):
             job_id
         )
 
+    def _upload_local_runtime_env(
+        self,
+        cloud_id: str,
+        cloud_deployment_id: Optional[str],
+        zip_file_bytes: bytes,
+        content_hash: str,
+        overwrite_existing_file: bool,
+    ) -> CloudDataBucketPresignedUrlResponse:
+        file_name = RUNTIME_ENV_PACKAGE_FORMAT.format(content_hash=content_hash)
+        request = CloudDataBucketPresignedUrlRequest(
+            file_type=CloudDataBucketFileType.RUNTIME_ENV_PACKAGES,
+            file_name=file_name,
+            access_mode=CloudDataBucketAccessMode.WRITE,
+            cloud_deployment_id=cloud_deployment_id,
+        )
+        info: CloudDataBucketPresignedUrlResponse = self._internal_api_client.generate_cloud_data_bucket_presigned_url_api_v2_clouds_cloud_id_generate_cloud_data_bucket_presigned_url_post(
+            cloud_id, request
+        ).result
+
+        # Skip the upload entirely if the file already exists.
+        if info.file_exists and not overwrite_existing_file:
+            internal_logger.debug(
+                f"Skipping file upload for '{file_name}' because it already exists in cloud storage."
+            )
+            return info
+
+        if info.url_scheme == CloudDataBucketPresignedUrlScheme.SMART_OPEN:
+            # If the presigned URL scheme is SMART_OPEN, upload to cloud storage using the provided bucket name, path, & environment, and the smart_open library.
+            bucket_name = info.bucket_name
+            bucket_path = info.bucket_path
+
+            env_vars: Dict[str, str] = {
+                "AWS_ENDPOINT_URL": info.url,
+            }
+            with set_env(**env_vars), smart_open.open(
+                f"{bucket_name}/{bucket_path}", "wb",
+            ) as fout:
+                fout.write(zip_file_bytes)
+
+        else:
+            # Default to HTTP PUT.
+            internal_logger.debug(f"Uploading file '{file_name}' to cloud storage.")
+            headers = None
+            if info.file_uri.startswith("azure") or info.file_uri.startswith("abfss"):
+                headers = {
+                    "x-ms-blob-type": "BlockBlob",
+                    "x-ms-version": "2025-07-05",
+                    "x-ms-date": datetime.utcnow().strftime(
+                        "%a, %d %b %Y %H:%M:%S GMT"
+                    ),
+                    "x-ms-blob-content-type": "application/zip",
+                }
+            requests.put(
+                info.url, data=zip_file_bytes, headers=headers
+            ).raise_for_status()
+
+        return info
+
     @handle_api_exceptions
     def upload_local_dir_to_cloud_storage(
         self,
@@ -1251,63 +1355,91 @@ class AnyscaleClient(AnyscaleClientInterface):
         cloud_id: str,
         excludes: Optional[List[str]] = None,
         overwrite_existing_file: bool = OVERWRITE_EXISTING_CLOUD_STORAGE_FILES,
+        cloud_deployment: Optional[str] = None,
     ) -> str:
         if not pathlib.Path(local_dir).is_dir():
             raise RuntimeError(f"Path '{local_dir}' is not a valid directory.")
 
+        cloud_deployment_id = None
+        if cloud_deployment is not None:
+            cloud_deployments = self._internal_api_client.get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get(
+                cloud_id=cloud_id,
+            ).results
+            cloud_deployment_id = next(
+                (
+                    deployment.cloud_deployment_id
+                    for deployment in cloud_deployments
+                    if deployment.name == cloud_deployment
+                ),
+                None,
+            )
+            if cloud_deployment_id is None:
+                raise ValueError(
+                    f"Cloud deployment '{cloud_deployment}' not found in cloud '{cloud_id}'"
+                )
+
         with zip_local_dir(local_dir, excludes=excludes) as (
             _,
             zip_file_bytes,
             content_hash,
         ):
-            file_name = RUNTIME_ENV_PACKAGE_FORMAT.format(content_hash=content_hash)
-            request = CloudDataBucketPresignedUrlRequest(
-                file_type=CloudDataBucketFileType.RUNTIME_ENV_PACKAGES,
-                file_name=file_name,
-                access_mode=CloudDataBucketAccessMode.WRITE,
+            info = self._upload_local_runtime_env(
+                cloud_id=cloud_id,
+                cloud_deployment_id=cloud_deployment_id,
+                zip_file_bytes=zip_file_bytes,
+                content_hash=content_hash,
+                overwrite_existing_file=overwrite_existing_file,
             )
-            info: CloudDataBucketPresignedUrlResponse = self._internal_api_client.generate_cloud_data_bucket_presigned_url_api_v2_clouds_cloud_id_generate_cloud_data_bucket_presigned_url_post(
-                cloud_id, request
-            ).result
+            return info.file_uri
 
-            # Skip the upload entirely if the file already exists.
-            if info.file_exists and not overwrite_existing_file:
-                internal_logger.debug(
-                    f"Skipping file upload for '{file_name}' because it already exists in cloud storage."
-                )
-                return info.file_uri
+    def upload_local_dir_to_cloud_storage_multi_deployment(
+        self,
+        local_dir: str,
+        *,
+        cloud_id: str,
+        cloud_deployments: List[Optional[str]],
+        excludes: Optional[List[str]] = None,
+        overwrite_existing_file: bool = False,
+    ) -> str:
+        if not pathlib.Path(local_dir).is_dir():
+            raise RuntimeError(f"Path '{local_dir}' is not a valid directory.")
 
-            if info.url_scheme == CloudDataBucketPresignedUrlScheme.SMART_OPEN:
-                # If the presigned URL scheme is SMART_OPEN, upload to cloud storage using the provided bucket name, path, & environment, and the smart_open library.
-                bucket_name = info.bucket_name
-                bucket_path = info.bucket_path
+        all_cloud_deployments = self._internal_api_client.get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get(
+            cloud_id=cloud_id,
+        ).results
+        cloud_deployment_ids = {
+            deployment.name: deployment.cloud_deployment_id
+            for deployment in all_cloud_deployments
+        }
 
-                env_vars: Dict[str, str] = {
-                    "AWS_ENDPOINT_URL": info.url,
-                }
-                with set_env(**env_vars), smart_open.open(
-                    f"{bucket_name}/{bucket_path}", "wb",
-                ) as fout:
-                    fout.write(zip_file_bytes)
+        bucket_paths = set()
 
-            else:
-                # Default to HTTP PUT.
-                internal_logger.debug(f"Uploading file '{file_name}' to cloud storage.")
-                headers = None
-                if info.file_uri.startswith("azure"):
-                    headers = {
-                        "x-ms-blob-type": "BlockBlob",
-                        "x-ms-version": "2025-07-05",
-                        "x-ms-date": datetime.utcnow().strftime(
-                            "%a, %d %b %Y %H:%M:%S GMT"
-                        ),
-                        "x-ms-blob-content-type": "application/zip",
-                    }
-                requests.put(
-                    info.url, data=zip_file_bytes, headers=headers
-                ).raise_for_status()
+        with zip_local_dir(local_dir, excludes=excludes) as (
+            _,
+            zip_file_bytes,
+            content_hash,
+        ):
+            for cloud_deployment in cloud_deployments:
+                if cloud_deployment is not None:
+                    if cloud_deployment not in cloud_deployment_ids:
+                        raise ValueError(
+                            f"Cloud deployment '{cloud_deployment}' not found in cloud '{cloud_id}'"
+                        )
+                    cloud_deployment_id = cloud_deployment_ids[cloud_deployment]
+                else:
+                    cloud_deployment_id = None
+
+                info = self._upload_local_runtime_env(
+                    cloud_id=cloud_id,
+                    cloud_deployment_id=cloud_deployment_id,
+                    zip_file_bytes=zip_file_bytes,
+                    content_hash=content_hash,
+                    overwrite_existing_file=overwrite_existing_file,
+                )
+                bucket_paths.add(info.bucket_path)
 
-        return info.file_uri
+            assert len(bucket_paths) == 1
+            return bucket_paths.pop()
 
     def _fetch_log_chunks(self, job_run_id: str) -> Tuple[List[str], Any]:
         all_log_chunk_urls = []

anyscale/_private/anyscale_client/common.py

@@ -25,10 +25,13 @@ from anyscale.client.openapi_client.models import (
     OrganizationCollaborator,
     OrganizationInvitation,
     Project,
+    ProjectBase,
+    ProjectListResponse,
     ResourceQuota,
     ServerSessionToken,
     SessionState,
     WorkspaceDataplaneProxiedArtifacts,
+    WriteProject,
 )
 from anyscale.client.openapi_client.models.create_schedule import CreateSchedule
 from anyscale.client.openapi_client.models.decorated_job_queue import DecoratedJobQueue
@@ -54,7 +57,7 @@ from anyscale.utils.workspace_notification import WorkspaceNotification
 # Maybe just make it part of the release process to update it, or fetch the
 # default builds and get the latest one. The best thing to do is probably
 # to populate this in the backend.
-DEFAULT_RAY_VERSION = "2.48.0"  # RAY_RELEASE_UPDATE: update to latest version.
+DEFAULT_RAY_VERSION = "2.49.0"  # RAY_RELEASE_UPDATE: update to latest version.
 DEFAULT_PYTHON_VERSION = "py311"
 RUNTIME_ENV_PACKAGE_FORMAT = "pkg_{content_hash}.zip"
 
@@ -355,13 +358,44 @@ class AnyscaleClientInterface(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_project(self, project_id: str) -> Optional[Project]:
+    def get_project(self, project_id: str) -> Project:
         """Get a project by id.
 
         Returns None if not found.
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def list_projects(
+        self,
+        *,
+        name_contains: Optional[str] = None,
+        creator_id: Optional[str] = None,
+        parent_cloud_id: Optional[str] = None,
+        include_defaults: bool = True,
+        sort_field: Optional[str] = None,
+        sort_order: Optional[str] = None,
+        paging_token: Optional[str] = None,
+        count: Optional[int] = None,
+    ) -> ProjectListResponse:
+        """List projects."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_project(self, project: WriteProject) -> ProjectBase:
+        """Create a project."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_project(self, project_id: str) -> None:
+        """Delete a project."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_default_project(self, parent_cloud_id: str) -> Project:
+        """Get the default project for the provided cloud ID."""
+        raise NotImplementedError
+
     @abstractmethod
     def add_project_collaborators(
         self, project_id: str, collaborators: List[CreateUserProjectCollaborator]
@@ -486,6 +520,7 @@ class AnyscaleClientInterface(ABC):
         cloud_id: str,
         excludes: Optional[List[str]] = None,
         overwrite_existing_file: bool = False,
+        cloud_deployment: Optional[str] = None,
     ) -> str:
         """Upload the provided directory to cloud storage and return a URI for it.
 
@@ -499,6 +534,30 @@ class AnyscaleClientInterface(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def upload_local_dir_to_cloud_storage_multi_deployment(
+        self,
+        local_dir: str,
+        *,
+        cloud_id: str,
+        cloud_deployments: List[Optional[str]],
+        excludes: Optional[List[str]] = None,
+        overwrite_existing_file: bool = False,
+    ) -> str:
+        """Upload the provided directory to the object storage for each of the provided
+        cloud deployments and return the bucket path of the uploaded file.
+
+        The directory will be zipped and the resulting bucket path will later be converted
+        to a URI that can be used in a Ray runtime_env.
+
+        The upload is preformed using a pre-signed URL fetched from Anyscale, so no
+        local cloud provider authentication is required.
+
+        The path is content-addressable (containing a hash of the directory contents), so by
+        default if the target file path already exists it will not be overwritten.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def logs_for_job_run(
         self,

anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -47,9 +47,12 @@ from anyscale.client.openapi_client.models import (
     ProductionJob,
     ProductionJobStateTransition,
     Project,
+    ProjectBase,
+    ProjectListResponse,
     ResourceQuota,
     ServerSessionToken,
     WorkspaceDataplaneProxiedArtifacts,
+    WriteProject,
 )
 from anyscale.client.openapi_client.models.create_schedule import CreateSchedule
 from anyscale.client.openapi_client.models.decorated_job_queue import DecoratedJobQueue
@@ -108,7 +111,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
 
     SCHEDULE_NEXT_TRIGGER_AT_TIME = datetime.utcnow()
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._builds: Dict[str, ClusterEnvironmentBuild] = {
             self.DEFAULT_CLUSTER_ENV_BUILD_ID: ClusterEnvironmentBuild(
                 id=self.DEFAULT_CLUSTER_ENV_BUILD_ID,
@@ -155,7 +158,8 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._jobs: Dict[str, ProductionJob] = {}
         self._job_runs: Dict[str, List[APIJobRun]] = defaultdict(list)
         self._job_queues: Dict[str, DecoratedJobQueue] = {}
-        self._project_to_id: Dict[Optional[str] : Dict[Optional[str], str]] = {}
+        self._project_to_id: Dict[Optional[str] : Dict[Optional[str], str]] = {}  # type: ignore
+        self._projects: Dict[str, Project] = {}
         self._project_collaborators: Dict[str, List[CreateUserProjectCollaborator]] = {}
         self._rolled_out_model: Optional[ApplyProductionServiceV2Model] = None
         self._sent_workspace_notifications: List[WorkspaceNotification] = []
@@ -164,6 +168,9 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._archived_jobs: Dict[str, ProductionJob] = {}
         self._requirements_path: Optional[str] = None
         self._upload_uri_mapping: Dict[str, str] = {}
+        self._upload_bucket_path_mapping: Dict[
+            str, Tuple[List[Optional[str]], str]
+        ] = {}
         self._submitted_job: Optional[CreateInternalProductionJob] = None
         self._env_vars: Optional[Dict[str, str]] = None
         self._job_run_logs: Dict[str, str] = {}
@@ -680,18 +687,128 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
 
         return None
 
+    def build_project_with_args(self, **kwargs) -> Project:
+        # set values for required fields if not provided
+        if "id" not in kwargs:
+            kwargs["id"] = f"project-id-{uuid.uuid4()!s}"
+        if "name" not in kwargs:
+            kwargs["name"] = f"project-{kwargs['id']}"
+        if "description" not in kwargs:
+            kwargs["description"] = f"project-description-{kwargs['id']}"
+        if "parent_cloud_id" not in kwargs:
+            kwargs["parent_cloud_id"] = self.DEFAULT_CLOUD_ID
+        if "created_at" not in kwargs:
+            kwargs["created_at"] = datetime.utcnow()
+        if "is_owner" not in kwargs:
+            kwargs["is_owner"] = True
+        if "is_read_only" not in kwargs:
+            kwargs["is_read_only"] = False
+        if "directory_name" not in kwargs:
+            kwargs["directory_name"] = "default"
+        if "is_default" not in kwargs:
+            kwargs["is_default"] = False
+        return Project(**kwargs, local_vars_configuration=OPENAPI_NO_VALIDATION)
+
+    def create_project_with_args(self, **kwargs) -> str:
+        project = self.build_project_with_args(**kwargs)
+        project_id: str = project.id  # type: ignore
+        self._projects[project_id] = project
+        return project_id
+
+    def get_project_by_id_or_name(
+        self, *, project_id: Optional[str] = None, project_name: Optional[str] = None,
+    ) -> Optional[Project]:
+        if project_id:
+            return self._projects.get(project_id, None)
+        if project_name:
+            for project in self._projects.values():
+                if project.name == project_name:
+                    return project
+        return None
+
     def get_project(self, project_id: str) -> Optional[Project]:
         for cloud_project_dict in self._project_to_id.values():
             for p_name, p_id in cloud_project_dict.items():
                 if p_id == project_id:
                     # return stub project
-                    return Project(
-                        name=p_name,
-                        id=p_id,
-                        local_vars_configuration=OPENAPI_NO_VALIDATION,
-                    )
+                    return self.build_project_with_args(id=p_id, name=p_name,)
         return None
 
+    def list_projects(
+        self,
+        *,
+        name_contains: Optional[str] = None,
+        creator_id: Optional[str] = None,
+        parent_cloud_id: Optional[str] = None,
+        include_defaults: bool = True,
+        sort_field: Optional[str] = None,  # noqa: ARG002
+        sort_order: Optional[str] = None,  # noqa: ARG002
+        paging_token: Optional[str] = None,  # noqa: ARG002
+        count: Optional[int] = None,
+    ) -> ProjectListResponse:
+        projects = list(self._projects.values())
+        if name_contains:
+            projects = [p for p in projects if p.name and name_contains in p.name]
+        if creator_id:
+            projects = [p for p in projects if p.creator_id == creator_id]
+        if parent_cloud_id:
+            projects = [p for p in projects if p.parent_cloud_id == parent_cloud_id]
+        if not include_defaults:
+            projects = [p for p in projects if not p.is_default]
+        if sort_field and sort_order and sort_field == "NAME":
+            projects.sort(
+                key=lambda x: x.name if x.name else "", reverse=sort_order == "DESC"
+            )
+        if count:
+            projects = projects[:count]
+        return ProjectListResponse(
+            results=projects,
+            metadata=ListResponseMetadata(
+                next_paging_token=paging_token,
+                local_vars_configuration=OPENAPI_NO_VALIDATION,
+            ),
+            local_vars_configuration=OPENAPI_NO_VALIDATION,
+        )
+
+    def create_project(self, project: WriteProject) -> ProjectBase:
+        project_id = f"project-id-{uuid.uuid4()!s}"
+        self._projects[project_id] = Project(
+            id=project_id,
+            name=project.name,
+            description=project.description,
+            cloud_id=project.cloud_id,
+            initial_cluster_config=project.initial_cluster_config,
+            parent_cloud_id=project.parent_cloud_id,
+            created_at=datetime.utcnow(),
+            creator_id=self.DEFAULT_USER_ID,
+            is_default=False,
+            is_owner=True,
+            is_read_only=False,
+            directory_name="default",
+            owners=[
+                MiniUser(
+                    id=self.DEFAULT_USER_ID,
+                    email=self.DEFAULT_USER_EMAIL,
+                    local_vars_configuration=OPENAPI_NO_VALIDATION,
+                )
+            ],
+            local_vars_configuration=OPENAPI_NO_VALIDATION,
+        )
+        return ProjectBase(
+            id=project_id, local_vars_configuration=OPENAPI_NO_VALIDATION,
+        )
+
+    def delete_project(self, project_id: str) -> None:
+        if project_id not in self._projects:
+            raise ValueError(f"Project {project_id} not found")
+        self._projects.pop(project_id)
+
+    def get_default_project(self, parent_cloud_id: str) -> Project:
+        for project in self._projects.values():
+            if project.parent_cloud_id == parent_cloud_id and project.is_default:
+                return project
+        raise ValueError(f"No default project found for cloud {parent_cloud_id}")
+
     def add_project_collaborators(
         self, project_id: str, collaborators: List[CreateUserProjectCollaborator]
     ):
@@ -897,14 +1014,17 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
 
     def upload_local_dir_to_cloud_storage(
         self,
-        local_dir: str,  # noqa: ARG002
+        local_dir: str,
         *,
         cloud_id: str,
         excludes: Optional[List[str]] = None,  # noqa: ARG002
         overwrite_existing_file: bool = False,  # noqa: ARG002
+        cloud_deployment: Optional[str] = None,
     ) -> str:
         # Ensure that URIs are consistent for the same passed directory.
         bucket = self.CLOUD_BUCKET.format(cloud_id=cloud_id)
+        if cloud_deployment is not None:
+            bucket += f"_{cloud_deployment}"
         if local_dir not in self._upload_uri_mapping:
             self._upload_uri_mapping[
                 local_dir
@@ -912,6 +1032,23 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
 
         return self._upload_uri_mapping[local_dir]
 
+    def upload_local_dir_to_cloud_storage_multi_deployment(
+        self,
+        local_dir: str,
+        *,
+        cloud_id: str,
+        cloud_deployments: List[Optional[str]],
+        excludes: Optional[List[str]] = None,  # noqa: ARG002
+        overwrite_existing_file: bool = False,  # noqa: ARG002
+    ) -> str:
+        bucket = self.CLOUD_BUCKET.format(cloud_id=cloud_id)
+        if local_dir not in self._upload_bucket_path_mapping:
+            self._upload_bucket_path_mapping[local_dir] = (
+                cloud_deployments,
+                f"{bucket}/fake_pkg_{str(uuid.uuid4())}.zip",
+            )
+        return self._upload_bucket_path_mapping[local_dir][1]
+
     def add_job_run_logs(self, job_run_id: str, logs: str):
         self._job_run_logs[job_run_id] = logs