anyscale 0.26.47__py3-none-any.whl → 0.26.49__py3-none-any.whl

anyscale/__init__.py

@@ -26,7 +26,6 @@ from anyscale import (
     integrations,
     job,
     job_queue,
-    llm,
     organization_invitation,
     project,
     resource_quota,
@@ -48,7 +47,6 @@ from anyscale.connect import ClientBuilder
 from anyscale.image import ImageSDK
 from anyscale.job import JobSDK
 from anyscale.job_queue import JobQueueSDK
-from anyscale.llm import LLMSDK
 from anyscale.organization_invitation import OrganizationInvitationSDK
 from anyscale.project import ProjectSDK
 from anyscale.resource_quota import ResourceQuotaSDK
@@ -127,7 +125,6 @@ class Anyscale:
         self._cloud_sdk = CloudSDK(client=self._anyscale_client)
         self._schedule_sdk = ScheduleSDK(client=self._anyscale_client)
         self._image_sdk = ImageSDK(client=self._anyscale_client)
-        self._llm_sdk = LLMSDK(client=self._anyscale_client)
         self._organization_invitation_sdk = OrganizationInvitationSDK(
             client=self._anyscale_client
         )
@@ -217,10 +214,6 @@ class Anyscale:
     def image(self) -> ImageSDK:  # noqa: F811
         return self._image_sdk
 
-    @property
-    def llm(self) -> LLMSDK:  # noqa: F811
-        return self._llm_sdk
-
     @property
     def organization_invitation(self) -> OrganizationInvitationSDK:  # noqa: F811
         return self._organization_invitation_sdk

anyscale/_private/anyscale_client/README.md

@@ -7,6 +7,17 @@ The purpose of centralizing this logic is to:
 - Keep all external dependencies in one place.
 - Enable writing comprehensive unit tests for upstream components (without using mocks!) using the `FakeAnyscaleClient`.
 
+## Installation
+
+To install the anyscale client package in development mode:
+
+```bash
+cd frontend/cli
+pip install -e .
+```
+
+This will install the `anyscale` package in editable mode, allowing you to make changes to the code and have them immediately available.
+
 ## Testing
 
 The `AnyscaleClient` is tested using a fake version of the internal and external OpenAPI clients.
@@ -14,3 +25,107 @@ The `AnyscaleClient` is tested using a fake version of the internal and external
 Upstream components should use the `FakeAnyscaleClient` to write their tests.
 This client should mirror the behavior of the real `AnyscaleClient` as closely as possible (avoid making methods and functionality
 complete "dummies").
+
+### Running Tests
+
+1. **Unit Tests**: Run the test suite to verify client functionality
+   ```bash
+   cd frontend/cli
+   python -m pytest tests/unit/test_anyscale_client.py
+   ```
+
+2. **Integration Tests**: Test the client against the actual Anyscale API
+   ```bash
+   # Set up your Anyscale credentials
+   export ANYSCALE_TOKEN="your_token_here"
+
+   # Run integration tests
+   python -m pytest tests/test_integrations.py
+   ```
+
+3. **All Client-Related Tests**: Run all tests that use the anyscale client
+   ```bash
+   cd frontend/cli
+   python -m pytest tests/ -k "anyscale_client" -v
+   ```
+
+### Testing Job Submission
+
+To test job submission functionality:
+
+1. **Create a test job configuration file** (`job.yaml`):
+   ```yaml
+   name: test-job
+   compute_config: default:1
+   working_dir: /path/to/working/directory
+   requirements:
+   - numpy==1.24.0
+   - pandas==2.0.0
+   entrypoint: python your_script.py
+   max_retries: 0
+   ```
+
+2. **Submit a test job**:
+   ```bash
+   anyscale job submit -f job.yaml
+   ```
+
+3. **Monitor job status**:
+   ```bash
+   anyscale job status <job_id>
+   ```
+
+4. **View job logs**:
+   ```bash
+   anyscale job logs <job_id>
+   ```
+
+### Example Test Job
+
+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
+requirements:
+- matplotlib==3.10.0
+- torch==2.7.1
+- transformers==4.52.3
+- scikit-learn==1.6.0
+- mlflow==2.19.0
+- ipywidgets==8.1.3
+entrypoint: python doggos/embed.py
+max_retries: 0
+```
+
+### Testing with Fake Client
+
+For unit testing components that depend on the Anyscale client:
+
+```python
+from anyscale._private.anyscale_client import FakeAnyscaleClient
+
+# Create a fake client for testing
+fake_client = FakeAnyscaleClient()
+
+# Use the fake client in your tests
+# The fake client should behave like the real client
+result = fake_client.submit_job(job_config)
+assert result.job_id is not None
+```
+
+### Debugging
+
+- Use `--verbose` flag for detailed output: `anyscale job submit -f job.yaml --verbose`
+- Check job status in the UI: The CLI will provide a URL to view the job in the Anyscale console
+- Use `--wait` flag to wait for job completion and stream logs: `anyscale job submit -f job.yaml --wait`
+
+### Common Issues
+
+1. **Authentication**: Ensure your Anyscale token is properly set
+2. **Network**: Check your internet connection and firewall settings
+3. **Dependencies**: Verify all required packages are installed
+4. **Job Configuration**: Ensure your YAML file is properly formatted
+
+For more detailed testing scenarios, refer to the test files in the `tests/` directory.

anyscale/_private/anyscale_client/anyscale_client.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 import contextlib
+from datetime import datetime
 from functools import wraps
 import io
 import json
@@ -23,12 +24,7 @@ from anyscale._private.anyscale_client.common import (
     RUNTIME_ENV_PACKAGE_FORMAT,
 )
 from anyscale._private.models.image_uri import ImageURI
-from anyscale._private.models.model_base import InternalListResponse, ListResponse
-from anyscale._private.utils.progress_util import (
-    FileDownloadProgress,
-    ProgressFileReader,
-)
-from anyscale.api_utils.common_utils import source_cloud_id_and_project_id
+from anyscale._private.utils.progress_util import FileDownloadProgress
 from anyscale.api_utils.logs_util import _download_log_from_s3_url_sync
 from anyscale.authenticate import AuthenticationBlock, get_auth_api_client
 from anyscale.cli_logger import BlockLogger
@@ -53,23 +49,17 @@ from anyscale.client.openapi_client.models import (
     ComputeTemplateQuery,
     CreateCloudCollaborator,
     CreateComputeTemplate,
-    CreateDataset,
     CreateExperimentalWorkspace,
     CreateInternalProductionJob,
     CreateOrganizationInvitation,
     CreateResourceQuota,
     CreateUserProjectCollaborator,
-    Dataset as InternalDataset,
-    DatasetUpload,
     DecoratedComputeTemplate,
     DecoratedjobqueueListResponse,
     DecoratedlistserviceapimodelListResponse,
     DecoratedProductionServiceV2APIModel,
     DecoratedSession,
-    DeletedPlatformFineTunedModel,
     ExperimentalWorkspace,
-    FineTunedModel,
-    FinetunedmodelListResponse,
     GetOrCreateBuildFromImageUriRequest,
     InternalProductionJob,
     JobQueueSortDirective,
@@ -1303,11 +1293,16 @@ class AnyscaleClient(AnyscaleClientInterface):
             else:
                 # Default to HTTP PUT.
                 internal_logger.debug(f"Uploading file '{file_name}' to cloud storage.")
-                headers = (
-                    {"x-ms-blob-type": "BlockBlob"}
-                    if info.file_uri.startswith("azure")
-                    else None
-                )
+                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()
@@ -1564,160 +1559,6 @@ class AnyscaleClient(AnyscaleClientInterface):
             id
         )
 
-    @handle_api_exceptions
-    def get_dataset(self, name: str, version: Optional[int], project: Optional[str]):
-        project_id = self._source_project_id(project)
-        internal_dataset = self._internal_api_client.find_dataset_api_v2_datasets_find_get(
-            name=name, version=version, project_id=project_id
-        ).result
-        from anyscale.llm.dataset._private.models import Dataset
-
-        dataset = Dataset.parse_from_internal_model(internal_dataset)
-        return dataset
-
-    def upload_dataset(
-        self,
-        dataset_file: str,
-        name: Optional[str],
-        description: Optional[str],
-        cloud: Optional[str],
-        project: Optional[str],
-    ):
-        # Resolve `~/.../file` to `/home/user/.../file`
-        dataset_file = os.path.expanduser(dataset_file)
-
-        if not os.path.isfile(dataset_file):
-            raise ValueError(f"Path '{dataset_file}' is not a valid file.")
-        dataset_file_size = os.path.getsize(dataset_file)
-        if dataset_file_size > 5 * Bytes.GB:
-            raise ValueError(
-                f"File '{dataset_file}' is too large to upload. The maximum size is 5 GB."
-            )
-        project_id = self._get_project_id_by_name(name=project) if project else None
-        cloud_id = self.get_cloud_id(cloud_name=cloud) if cloud else None
-
-        with FileDownloadProgress() as progress:
-            task_id = progress.add_task(
-                description=f"Creating an upload request for '{dataset_file}'",
-                total=dataset_file_size,
-            )
-            _, project_id = source_cloud_id_and_project_id(
-                internal_api=self._internal_api_client,
-                external_api=self._external_api_client,
-                cloud_id=cloud_id,
-                project_id=project_id,
-            )
-            dataset_upload: DatasetUpload = self._internal_api_client.create_dataset_upload_api_v2_datasets_upload_post(
-                create_dataset=CreateDataset(
-                    filename=os.path.basename(dataset_file),
-                    description=description,
-                    name=name,
-                    project_id=project_id,
-                )
-            ).result
-
-            progress.update(task_id, description=f"Uploading '{dataset_file}'")
-
-            with open(dataset_file, "rb") as file_reader:
-                progress_reader = ProgressFileReader(file_reader, progress, task_id)
-                response = requests.put(
-                    dataset_upload.upload_url, data=progress_reader,
-                )
-                response.raise_for_status()
-
-            progress.update(task_id, completed=os.path.getsize(dataset_file))
-            progress.console.print(
-                "Upload complete!", style=Style(bold=True, color="green")
-            )
-        internal_dataset = dataset_upload.dataset
-        from anyscale.llm.dataset._private.models import Dataset
-
-        dataset = Dataset.parse_from_internal_model(internal_dataset)
-        return dataset
-
-    @handle_api_exceptions
-    def download_dataset(
-        self, name: str, version: Optional[int], project: Optional[str]
-    ) -> bytes:
-        project_id = self._source_project_id(project)
-        with FileDownloadProgress() as progress:
-            task_id = progress.add_task(
-                description=f"Getting download info for '{name}'",
-            )
-            download_url: str = self._internal_api_client.get_dataset_download_url_api_v2_datasets_download_get(
-                name, version=version, project_id=project_id,
-            )
-            progress.update(task_id, description=f"Downloading '{name}'")
-            response = requests.get(download_url, stream=True)
-            total_size = int(response.headers.get("content-length", 0))
-            progress.update(task_id, total=total_size)
-
-            # For CLI, consider writing to disk instead of loading the entire file into memory.
-            dataset_bytes = b""
-            for data in response.iter_content(Bytes.MB):
-                dataset_bytes += data
-                progress.update(task_id, advance=len(data))
-
-            progress.update(task_id, completed=total_size)
-            progress.console.print(
-                "Download complete!", style=Style(bold=True, color="green")
-            )
-
-        return dataset_bytes
-
-    @handle_api_exceptions
-    def list_datasets(
-        self,
-        limit: Optional[int] = None,
-        after: Optional[str] = None,  # Unique ID to start listing after
-        name_contains: Optional[str] = None,
-        cloud: Optional[str] = None,
-        project: Optional[str] = None,
-    ):
-        project_id = self._source_project_id(project)
-        cloud_id = self.get_cloud_id(cloud_name=cloud) if cloud else None
-
-        def get_next_page(
-            after_id: Optional[str],
-        ) -> InternalListResponse[InternalDataset]:
-            internal_datasets: InternalListResponse = self._internal_api_client.list_datasets_api_v2_datasets_get(
-                project_id=project_id,
-                cloud_id=cloud_id,
-                name_contains=name_contains,
-                after=after_id,
-            )
-            return internal_datasets
-
-        from anyscale.llm.dataset._private.models import Dataset
-
-        list_response = ListResponse(
-            after=after, limit=limit, get_next_page=get_next_page, cls=Dataset,
-        )
-        return list_response
-
-    def _source_project_id(self, project_name: Optional[str]) -> Optional[str]:
-        """Sources a optional project ID from an optionally-provided project name."""
-        if project_name:
-            project_id = self._get_project_id_by_name(name=project_name)
-        else:
-            project_id = None
-        return project_id
-
-    @handle_api_exceptions
-    def get_finetuned_model(
-        self, model_id: Optional[str], job_id: Optional[str]
-    ) -> FineTunedModel:
-        if model_id:
-            return self._internal_api_client.get_model_api_v2_llm_models_model_id_get(
-                model_id
-            ).result
-        elif job_id:
-            return self._internal_api_client.get_model_by_job_id_api_v2_llm_models_get_by_job_id_job_id_get(
-                job_id
-            ).result
-        else:
-            raise ValueError("Atleast one of `model_id` or `job_id` must be provided")
-
     @handle_api_exceptions
     def create_workspace(self, model: CreateExperimentalWorkspace) -> str:
         return self._internal_api_client.create_workspace_api_v2_experimental_workspaces_post(
@@ -1898,48 +1739,6 @@ class AnyscaleClient(AnyscaleClientInterface):
         else:
             return project.name
 
-    @handle_api_exceptions
-    def delete_finetuned_model(self, model_id: str) -> DeletedPlatformFineTunedModel:
-        deleted_model = self._internal_api_client.delete_model_api_v2_llm_models_model_id_delete(
-            model_id
-        ).result
-        return deleted_model
-
-    @handle_api_exceptions
-    def list_finetuned_models(
-        self, cloud_id: Optional[str], project_id: Optional[str], max_items: int,
-    ) -> List[FineTunedModel]:
-        if self.inside_workspace():
-            # Resolve `cloud_id` and `project_id`. If not provided and if this is being run in a workspace,
-            # we use the `cloud_id` and `project_id` of the workspace
-            cloud_id, project_id = source_cloud_id_and_project_id(
-                internal_api=self._internal_api_client,
-                external_api=self._external_api_client,
-                cloud_id=cloud_id,
-                project_id=project_id,
-            )
-
-        paging_token = None
-        results = []
-        while True:
-            count = min(self.LIST_ENDPOINT_COUNT, max_items)
-            resp: FinetunedmodelListResponse = self._internal_api_client.list_models_api_v2_llm_models_get(
-                cloud_id=cloud_id,
-                project_id=project_id,
-                paging_token=paging_token,
-                count=count,
-            )
-            models = resp.results
-            results.extend(models)
-            if not len(models) or not resp.metadata.next_paging_token:
-                break
-
-            if max_items and len(results) >= max_items:
-                break
-            paging_token = resp.metadata.next_paging_token
-
-        return results[:max_items] if max_items else results
-
     @handle_api_exceptions
     def download_aggregated_instance_usage_csv(
         self,

anyscale/_private/anyscale_client/common.py

@@ -20,8 +20,6 @@ from anyscale.client.openapi_client.models import (
     DecoratedjobqueueListResponse,
     DecoratedlistserviceapimodelListResponse,
     DecoratedProductionServiceV2APIModel,
-    DeletedPlatformFineTunedModel,
-    FineTunedModel,
     InternalProductionJob,
     JobQueueSortDirective,
     OrganizationCollaborator,
@@ -575,41 +573,6 @@ class AnyscaleClientInterface(ABC):
         """
         raise NotImplementedError
 
-    @abstractmethod
-    def get_dataset(self, name: str, version: Optional[int], project: Optional[str]):
-        """See docstring for `anyscale.llm.dataset.get()`."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def upload_dataset(
-        self,
-        dataset_file: str,
-        name: Optional[str],
-        description: Optional[str],
-        cloud: Optional[str],
-        project: Optional[str],
-    ):
-        """See docstring for `anyscale.llm.dataset.upload()`."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def download_dataset(
-        self, name: str, version: Optional[int], project: Optional[str]
-    ) -> bytes:
-        """See docstring for `anyscale.llm.dataset.download()`."""
-
-    @abstractmethod
-    def list_datasets(
-        self,
-        limit: Optional[int] = None,
-        after: Optional[str] = None,  # Unique ID to start listing after
-        name_contains: Optional[str] = None,
-        cloud: Optional[str] = None,
-        project: Optional[str] = None,
-    ):
-        """See docstring for `anyscale.llm.dataset.list()`."""
-        raise NotImplementedError
-
     @abstractmethod
     def create_workspace(self, model: CreateExperimentalWorkspace) -> str:
         """Creates a workspace
@@ -657,13 +620,6 @@ class AnyscaleClientInterface(ABC):
         """Updates the dynamic dependencies of a workspace"""
         raise NotImplementedError
 
-    @abstractmethod
-    def get_finetuned_model(
-        self, model_id: Optional[str], job_id: Optional[str]
-    ) -> FineTunedModel:  # noqa: A002
-        """Returns LLM model information for the given model ID"""
-        raise NotImplementedError
-
     @abstractmethod
     def get_workspace_cluster(
         self, workspace_id: Optional[str]
@@ -693,17 +649,6 @@ class AnyscaleClientInterface(ABC):
         """Get the default directory name for a workspace."""
         raise NotImplementedError
 
-    @abstractmethod
-    def delete_finetuned_model(self, model_id: str) -> DeletedPlatformFineTunedModel:
-        """Deletes a finetuned model from the model registry given the model ID"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def list_finetuned_models(
-        self, cloud_id: Optional[str], project_id: Optional[str], max_items: int,
-    ) -> List[FineTunedModel]:
-        raise NotImplementedError
-
     @abstractmethod
     def update_workspace(
         self,

anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -11,7 +11,6 @@ from anyscale._private.anyscale_client.common import (
     WORKSPACE_CLUSTER_NAME_PREFIX,
 )
 from anyscale._private.models.image_uri import ImageURI
-from anyscale._private.models.model_base import ListResponse
 from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client.models import (
     AdminCreatedUser,
@@ -58,7 +57,6 @@ from anyscale.client.openapi_client.models.decorated_schedule import DecoratedSc
 from anyscale.client.openapi_client.models.decorated_session import DecoratedSession
 from anyscale.client.openapi_client.models.session_ssh_key import SessionSshKey
 from anyscale.cluster_compute import parse_cluster_compute_name_version
-from anyscale.llm.dataset._private.models import Dataset
 from anyscale.sdk.anyscale_client.configuration import Configuration
 from anyscale.sdk.anyscale_client.models import (
     ApplyProductionServiceV2Model,
@@ -105,6 +103,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     WORKSPACE_CLUSTER_ID = "fake-workspace-cluster-id"
     WORKSPACE_PROJECT_ID = "fake-workspace-project-id"
     WORKSPACE_CLUSTER_COMPUTE_ID = "fake-workspace-cluster-compute-id"
+    WORKSPACE_CLUSTER_COMPUTE_NAME = "fake-workspace-cluster-compute"
     WORKSPACE_CLUSTER_ENV_BUILD_ID = "fake-workspace-cluster-env-build-id"
 
     SCHEDULE_NEXT_TRIGGER_AT_TIME = datetime.utcnow()
@@ -210,10 +209,28 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
             ),
             local_vars_configuration=OPENAPI_NO_VALIDATION,
         )
+
+        workspace_compute_config = ClusterCompute(
+            id=self.WORKSPACE_CLUSTER_COMPUTE_ID,
+            name=self.WORKSPACE_CLUSTER_COMPUTE_NAME,
+            config=ClusterComputeConfig(
+                cloud_id=self.WORKSPACE_CLOUD_ID,
+                head_node_type=ComputeNodeType(
+                    name="default-head-node",
+                    instance_type="m5.2xlarge",
+                    resources={"CPU": 8, "GPU": 1},
+                ),
+                local_vars_configuration=OPENAPI_NO_VALIDATION,
+            ),
+            local_vars_configuration=OPENAPI_NO_VALIDATION,
+        )
+
         self._default_compute_configs: Dict[str, ClusterCompute] = {
             self.DEFAULT_CLOUD_ID: compute_config,
+            self.WORKSPACE_CLOUD_ID: workspace_compute_config,
         }
         self.add_compute_config(compute_config)
+        self.add_compute_config(workspace_compute_config)
 
     def get_job_ui_url(self, job_id: str) -> str:
         return f"{self.BASE_UI_URL}/jobs/{job_id}"
@@ -993,50 +1010,6 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     def trigger_counts(self, id: str):  # noqa: A002
         return self._schedule_trigger_counts[id]
 
-    def get_dataset(
-        self, name: str, version: Optional[int], project: Optional[str]  # noqa: ARG002
-    ) -> Dataset:
-        raise NotImplementedError
-
-    def upload_dataset(
-        self,
-        dataset_file: str,  # noqa: ARG002
-        name: Optional[str],  # noqa: ARG002
-        description: Optional[str],  # noqa: ARG002
-        cloud: Optional[str],  # noqa: ARG002
-        project: Optional[str],  # noqa: ARG002
-    ) -> Dataset:
-        raise NotImplementedError
-
-    def download_dataset(
-        self, name: str, version: Optional[int], project: Optional[str]  # noqa: ARG002
-    ) -> bytes:
-        return b""
-
-    def list_datasets(
-        self,
-        limit: Optional[int] = None,  # noqa: ARG002
-        after: Optional[str] = None,  # noqa: ARG002
-        name_contains: Optional[str] = None,  # noqa: ARG002
-        cloud: Optional[str] = None,  # noqa: ARG002
-        project: Optional[str] = None,  # noqa: ARG002
-    ) -> ListResponse[Dataset]:
-        raise NotImplementedError
-
-    def get_finetuned_model(
-        self, model_id: Optional[str], job_id: Optional[str]  # noqa: ARG002
-    ) -> FineTunedModel:
-        return FineTunedModel(
-            id=model_id if model_id else "test-model-id",
-            model_id=model_id if model_id else "test-model-id",
-            base_model_id="my_base_model_id",
-            ft_type=FineTuneType.LORA,
-            creator_id="",
-            creator_email="",
-            created_at=datetime.utcnow(),
-            storage_uri="s3://fake_bucket/fake_folder/",
-        )
-
     def create_workspace(self, model: CreateExperimentalWorkspace) -> str:
         workspace_id = uuid.uuid4()