anyscale 0.24.53__tar.gz → 0.24.54__tar.gz

{anyscale-0.24.53 → anyscale-0.24.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anyscale
-Version: 0.24.53
+Version: 0.24.54
 Summary: Command Line Interface for Anyscale
 Author: Anyscale Inc.
 License: AS License

{anyscale-0.24.53 → anyscale-0.24.54}/anyscale/__init__.py

@@ -33,6 +33,7 @@ from anyscale.llm import LLMSDK
 from anyscale.schedule import ScheduleSDK
 from anyscale.sdk.anyscale_client.sdk import AnyscaleSDK
 from anyscale.service import ServiceSDK
+from anyscale.workspace import WorkspaceSDK
 
 
 # Note: indentation here matches that of connect.py::ClientBuilder.
@@ -94,6 +95,7 @@ class Anyscale:
         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._workspace_sdk = WorkspaceSDK(client=self._anyscale_client)
 
     @classmethod
     def _init_private(
@@ -114,7 +116,9 @@ class Anyscale:
             client=client, logger=logger, timer=timer,
         )
         obj._image_sdk = ImageSDK(client=client, logger=logger)  # noqa: SLF001
-        obj._llm_sdk = LLMSDK(client=client, logger=logger, timer=timer)  # noqa: SLF001
+        obj._workspace_sdk = WorkspaceSDK(  # noqa: SLF001
+            client=client, logger=logger, timer=timer,
+        )
         return obj
 
     @property
@@ -141,6 +145,10 @@ class Anyscale:
     def llm(self) -> LLMSDK:  # noqa: F811
         return self._llm_sdk
 
+    @property
+    def workspace(self) -> WorkspaceSDK:  # noqa: F811
+        return self._workspace_sdk
+
 
 def _validate_headers(headers: Optional[Dict[str, str]]):
     if not headers:

{anyscale-0.24.53 → anyscale-0.24.54}/anyscale/_private/anyscale_client/anyscale_client.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
+from functools import wraps
 import io
+import json
 import logging
 import os
 import pathlib
@@ -32,10 +34,13 @@ from anyscale.client.openapi_client.models import (
     ComputeTemplateConfig,
     ComputeTemplateQuery,
     CreateComputeTemplate,
+    CreateExperimentalWorkspace,
     CreateInternalProductionJob,
     DecoratedComputeTemplate,
     ExperimentalWorkspace,
     InternalProductionJob,
+    StartSessionOptions,
+    StopSessionOptions,
 )
 from anyscale.client.openapi_client.models.create_schedule import CreateSchedule
 from anyscale.client.openapi_client.models.decorated_schedule import DecoratedSchedule
@@ -98,6 +103,21 @@ OVERWRITE_EXISTING_CLOUD_STORAGE_FILES = (
 # internal_logger is used for logging internal errors or debug messages that we do not expect users to see.
 internal_logger = logging.getLogger(__name__)
 
+# A decorator to handle ApiException and raise ValueError with the error message.
+def handle_api_exceptions(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except ApiException as e:
+            if e.status >= 400 and e.status < 500:
+                body_dict = json.loads(e.body)
+                msg = body_dict["error"]["detail"]
+                raise ValueError(msg) from None
+            raise e from None
+
+    return wrapper
+
 
 class AWSS3ClientInterface(ABC):
     @abstractmethod
@@ -1025,22 +1045,11 @@ class AnyscaleClient(AnyscaleClientInterface):
         logs = self._read_log_lines(all_log_chunk_urls, head, bearer_token, max_lines)
         return logs
 
+    @handle_api_exceptions
     def apply_schedule(self, model: CreateSchedule) -> DecoratedSchedule:
-        try:
-            return self._internal_api_client.create_or_update_job_api_v2_experimental_cron_jobs_put(
-                model
-            ).result
-        except ApiException as e:
-            if e.status == 400 and (
-                "Please specify a valid cron expression" in e.body
-                or "Please specify a valid tz database timezone" in e.body
-            ):
-                import json
-
-                body_dict = json.loads(e.body)
-                msg = body_dict["error"]["detail"]
-                raise ValueError(msg) from None
-            raise e from None
+        return self._internal_api_client.create_or_update_job_api_v2_experimental_cron_jobs_put(
+            model
+        ).result
 
     def get_schedule(
         self,
@@ -1181,3 +1190,100 @@ class AnyscaleClient(AnyscaleClientInterface):
 
     def retrieve_finetuned_model(self, model_id: str) -> FineTunedModel:
         return self._external_api_client.get_model(model_id)
+
+    @handle_api_exceptions
+    def create_workspace(self, model: CreateExperimentalWorkspace) -> str:
+        return self._internal_api_client.create_workspace_api_v2_experimental_workspaces_post(
+            create_experimental_workspace=model,
+        ).result.id
+
+    def get_workspace(
+        self,
+        *,
+        id: Optional[str] = None,  # noqa: A002
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+    ) -> Optional[ExperimentalWorkspace]:
+        """Get a workspace by either name or id. Filter by cloud and project.
+
+        Returns None if not found.
+        """
+        if id is not None:
+            try:
+                return self._internal_api_client.get_workspace_api_v2_experimental_workspaces_workspace_id_get(
+                    id
+                ).result
+            except ExternalApiException as e:
+                if e.status == 404:
+                    return None
+                raise e from None
+        else:
+            paging_token = None
+            cloud_id = self.get_cloud_id(cloud_name=cloud)
+            project_id = self.get_project_id(parent_cloud_id=cloud_id, name=project)
+            resp = self._internal_api_client.list_workspaces_api_v2_experimental_workspaces_get(
+                project_id=project_id,
+                name=name,
+                count=self.LIST_ENDPOINT_COUNT,
+                paging_token=paging_token,
+            )
+
+            if len(resp.results) == 0:
+                return None
+
+            workspace = resp.results[0]
+            return workspace
+
+    @handle_api_exceptions
+    def update_workspace_dependencies_offline_only(
+        self, workspace_id: str, requirements: List[str]
+    ):
+        return self._internal_api_client.put_workspace_proxied_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_proxied_dataplane_artifacts_put(
+            workspace_id=workspace_id,
+            workspace_dataplane_proxied_artifacts={
+                "requirements": "\n".join(requirements),
+            },
+        )
+
+    @handle_api_exceptions
+    def update_workspace_env_vars_offline_only(
+        self, workspace_id: str, env_vars: Dict[str, str]
+    ):
+        return self._internal_api_client.put_workspace_proxied_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_proxied_dataplane_artifacts_put(
+            workspace_id=workspace_id,
+            workspace_dataplane_proxied_artifacts={
+                "environment_variables": [
+                    f"{key}={value}" for key, value in env_vars.items()
+                ],
+            },
+        )
+
+    @handle_api_exceptions
+    def start_workspace(self, workspace_id: str):
+        """Start a workspace."""
+        workspace_model = self.get_workspace(id=workspace_id)
+        if workspace_model is None:
+            raise ValueError(f"Workspace '{workspace_id}' not found.")
+
+        return self._internal_api_client.start_session_api_v2_sessions_session_id_start_post(
+            session_id=workspace_model.cluster_id,
+            start_session_options=StartSessionOptions(),
+        )
+
+    @handle_api_exceptions
+    def terminate_workspace(self, workspace_id: str):
+        """Terminate a workspace."""
+        workspace_model = self.get_workspace(id=workspace_id)
+        if workspace_model is None:
+            raise ValueError(f"Workspace '{workspace_id}' not found.")
+
+        options = StopSessionOptions(
+            terminate=True,
+            workers_only=False,
+            keep_min_workers=False,
+            take_snapshot=False,
+        )
+        return self._internal_api_client.stop_session_api_v2_sessions_session_id_stop_post(
+            session_id=workspace_model.cluster_id, stop_session_options=options,
+        )

{anyscale-0.24.53 → anyscale-0.24.54}/anyscale/_private/anyscale_client/common.py

@@ -5,6 +5,7 @@ from anyscale._private.models.image_uri import ImageURI
 from anyscale.client.openapi_client.models import (
     Cloud,
     ComputeTemplateConfig,
+    CreateExperimentalWorkspace,
     CreateInternalProductionJob,
     DecoratedComputeTemplate,
     InternalProductionJob,
@@ -420,6 +421,52 @@ class AnyscaleClientInterface(ABC):
         self, dataset_id_or_name: str, version: Optional[int]
     ) -> bytes:
         """See docstring for `anyscale.llm.dataset.download`."""
+
+    @abstractmethod
+    def create_workspace(self, model: CreateExperimentalWorkspace) -> str:
+        """Creates a workspace
+
+        Returns the id of the workspace created.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_workspace(
+        self,
+        *,
+        name: Optional[str],
+        id: Optional[str],  # noqa: A002
+        cloud: Optional[str],
+        project: Optional[str],
+    ) -> Optional[DecoratedSchedule]:
+        """Get a workspace by either name or id. Filter by cloud and project.
+
+        Returns None if not found.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def start_workspace(self, workspace_id: str):
+        """Start a workspace."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def terminate_workspace(self, workspace_id: str):
+        """Terminate a workspace."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_workspace_dependencies_offline_only(
+        self, workspace_id: str, requirements: List[str]
+    ):
+        """Updates the dynamic dependencies of a workspace while the workspace is offline"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_workspace_env_vars_offline_only(
+        self, workspace_id: str, env_vars: Dict[str, str]
+    ):
+        """Updates the dynamic dependencies of a workspace"""
         raise NotImplementedError
 
     @abstractmethod

{anyscale-0.24.53 → anyscale-0.24.54}/anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -13,8 +13,10 @@ from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client.models import (
     Cloud,
     ComputeTemplateConfig,
+    CreateExperimentalWorkspace,
     CreateInternalProductionJob,
     DecoratedComputeTemplate,
+    ExperimentalWorkspace,
     HaJobGoalStates,
     HaJobStates,
     InternalProductionJob,
@@ -65,6 +67,9 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     DEFAULT_CLUSTER_COMPUTE_NAME = "fake-default-cluster-compute"
     DEFAULT_CLUSTER_COMPUTE_ID = "fake-default-cluster-compute-id"
     DEFAULT_CLUSTER_ENV_BUILD_ID = "fake-default-cluster-env-build-id"
+    DEFAULT_USER_ID = "fake-user-id"
+    DEFAULT_USER_EMAIL = "user@email.com"
+    DEFAULT_ORGANIZATION_ID = "fake-org-id"
 
     WORKSPACE_ID = "fake-workspace-id"
     WORKSPACE_CLOUD_ID = "fake-workspace-cloud-id"
@@ -132,6 +137,9 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._job_run_logs: Dict[str, str] = {}
         self._schedules: Dict[str, DecoratedSchedule] = {}
         self._schedule_trigger_counts: Dict[str, int] = defaultdict(int)
+        self._workspaces: Dict[str, ExperimentalWorkspace] = {}
+        self._workspaces_dependencies: Dict[str, List[str]] = {}
+        self._workspaces_env_vars: Dict[str, Dict[str, str]] = {}
 
         # Cloud ID -> Cloud.
         self._clouds: Dict[str, Cloud] = {
@@ -833,3 +841,82 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
             created_at=datetime.utcnow(),
             storage_uri="s3://fake_bucket/fake_folder/",
         )
+
+    def create_workspace(self, model: CreateExperimentalWorkspace) -> str:
+        workspace_id = uuid.uuid4()
+
+        # this usually happens on the backend
+        compute_config = self.get_compute_config(model.compute_config_id)
+        assert compute_config is not None
+        compute_config.idle_timeout_minutes = model.idle_timeout_minutes
+
+        workspace = ExperimentalWorkspace(
+            id=f"workspace-id-{workspace_id!s}",
+            name=model.name,
+            project_id=model.project_id or self.get_project_id(),
+            compute_config_id=model.compute_config_id,
+            environment_id=model.cluster_environment_build_id,
+            cloud_id=model.cloud_id or self.get_cloud_id(),
+            created_at=datetime.now(),
+            creator_id=self.DEFAULT_USER_ID,
+            creator_email=self.DEFAULT_USER_EMAIL,
+            organization_id=self.DEFAULT_ORGANIZATION_ID,
+            cluster_id=self.DEFAULT_CLOUD_ID,
+            state="Running" if not model.skip_start else "Terminated",
+        )
+        self._workspaces[workspace.id] = workspace
+        return workspace.id
+
+    def get_workspace(
+        self,
+        *,
+        id: Optional[str] = None,  # noqa: A002
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+    ) -> Optional[ExperimentalWorkspace]:
+        if id is not None:
+            return self._workspaces.get(id, None)
+        else:
+            cloud_id = self.get_cloud_id(cloud_name=cloud)
+            cloud_project_dict = self._project_to_id.get(cloud_id, None)
+            project_id = (
+                cloud_project_dict.get(project, None) if cloud_project_dict else None
+            )
+            result: ExperimentalWorkspace = None
+            for workspace in self._workspaces.values():
+                if (
+                    workspace is not None
+                    and workspace.name == name
+                    and (project_id is None or workspace.project_id == project_id)
+                ):
+                    result = workspace
+                    break
+
+        return result
+
+    @property
+    def workspaces(self) -> Dict[str, ExperimentalWorkspace]:
+        return self._workspaces
+
+    def start_workspace(self, workspace_id: str):
+        workspace = self._workspaces.get(workspace_id, None)
+        if workspace is None:
+            raise ValueError(f"Workspace '{workspace_id}' not found.")
+        workspace.state = "Running"
+
+    def terminate_workspace(self, workspace_id: str):
+        workspace = self._workspaces.get(workspace_id, None)
+        if workspace is None:
+            raise ValueError(f"Workspace '{workspace_id}' not found.")
+        workspace.state = "Terminated"
+
+    def update_workspace_dependencies_offline_only(
+        self, workspace_id: str, requirements: List[str]
+    ):
+        self._workspaces_dependencies[workspace_id] = requirements
+
+    def update_workspace_env_vars_offline_only(
+        self, workspace_id: str, env_vars: Dict[str, str]
+    ):
+        self._workspaces_env_vars[workspace_id] = env_vars

{anyscale-0.24.53 → anyscale-0.24.54}/anyscale/client/README.md

@@ -175,6 +175,7 @@ Class | Method | HTTP request | Description
 *DefaultApi* | [**get_cluster_product_autoscaler_flag_api_v2_logs_cluster_product_autoscaler_flag_session_id_get**](docs/DefaultApi.md#get_cluster_product_autoscaler_flag_api_v2_logs_cluster_product_autoscaler_flag_session_id_get) | **GET** /api/v2/logs/cluster_product_autoscaler_flag/{session_id} | Get Cluster Product Autoscaler Flag
 *DefaultApi* | [**get_compute_template_api_v2_compute_templates_template_id_get**](docs/DefaultApi.md#get_compute_template_api_v2_compute_templates_template_id_get) | **GET** /api/v2/compute_templates/{template_id} | Get Compute Template
 *DefaultApi* | [**get_cron_job_api_v2_experimental_cron_jobs_cron_job_id_get**](docs/DefaultApi.md#get_cron_job_api_v2_experimental_cron_jobs_cron_job_id_get) | **GET** /api/v2/experimental_cron_jobs/{cron_job_id} | Get Cron Job
+*DefaultApi* | [**get_dataset_download_url_api_v2_datasets_download_get**](docs/DefaultApi.md#get_dataset_download_url_api_v2_datasets_download_get) | **GET** /api/v2/datasets/download | Get Dataset Download Url
 *DefaultApi* | [**get_decorated_cluster_api_v2_decorated_sessions_cluster_id_get**](docs/DefaultApi.md#get_decorated_cluster_api_v2_decorated_sessions_cluster_id_get) | **GET** /api/v2/decorated_sessions/{cluster_id} | Get Decorated Cluster
 *DefaultApi* | [**get_decorated_interactive_session_api_v2_decorated_interactive_sessions_interactive_session_id_get**](docs/DefaultApi.md#get_decorated_interactive_session_api_v2_decorated_interactive_sessions_interactive_session_id_get) | **GET** /api/v2/decorated_interactive_sessions/{interactive_session_id} | Get Decorated Interactive Session
 *DefaultApi* | [**get_decorated_interactive_session_logs_api_v2_decorated_interactive_sessions_interactive_session_id_logs_get**](docs/DefaultApi.md#get_decorated_interactive_session_logs_api_v2_decorated_interactive_sessions_interactive_session_id_logs_get) | **GET** /api/v2/decorated_interactive_sessions/{interactive_session_id}/logs | Get Decorated Interactive Session Logs

{anyscale-0.24.53 → anyscale-0.24.54}/anyscale/client/openapi_client/api/default_api.py

@@ -11676,6 +11676,130 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def get_dataset_download_url_api_v2_datasets_download_get(self, name, **kwargs):  # noqa: E501
+        """Get Dataset Download Url  # noqa: E501
+
+        Returns a short-lived URL that can be visited to download the dataset.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_dataset_download_url_api_v2_datasets_download_get(name, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str name: Name of the dataset to download. (required)
+        :param int version: Version of the dataset to download. If a negative integer is provided, the dataset returned is this many versions back of the latest version. Default: Latest version
+        :param str project_id: ID of the Anyscale project that the dataset belongs to.
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: str
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.get_dataset_download_url_api_v2_datasets_download_get_with_http_info(name, **kwargs)  # noqa: E501
+
+    def get_dataset_download_url_api_v2_datasets_download_get_with_http_info(self, name, **kwargs):  # noqa: E501
+        """Get Dataset Download Url  # noqa: E501
+
+        Returns a short-lived URL that can be visited to download the dataset.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.get_dataset_download_url_api_v2_datasets_download_get_with_http_info(name, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str name: Name of the dataset to download. (required)
+        :param int version: Version of the dataset to download. If a negative integer is provided, the dataset returned is this many versions back of the latest version. Default: Latest version
+        :param str project_id: ID of the Anyscale project that the dataset belongs to.
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: tuple(str, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'name',
+            'version',
+            'project_id'
+        ]
+        all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout'
+            ]
+        )
+
+        for key, val in six.iteritems(local_var_params['kwargs']):
+            if key not in all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_dataset_download_url_api_v2_datasets_download_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'name' is set
+        if self.api_client.client_side_validation and ('name' not in local_var_params or  # noqa: E501
+                                                        local_var_params['name'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `name` when calling `get_dataset_download_url_api_v2_datasets_download_get`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
+            query_params.append(('name', local_var_params['name']))  # noqa: E501
+        if 'version' in local_var_params and local_var_params['version'] is not None:  # noqa: E501
+            query_params.append(('version', local_var_params['version']))  # noqa: E501
+        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
+            query_params.append(('project_id', local_var_params['project_id']))  # noqa: E501
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = []  # noqa: E501
+
+        return self.api_client.call_api(
+            '/api/v2/datasets/download', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='str',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=local_var_params.get('async_req'),
+            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def get_decorated_cluster_api_v2_decorated_sessions_cluster_id_get(self, cluster_id, **kwargs):  # noqa: E501
         """Get Decorated Cluster  # noqa: E501
 
@@ -23534,6 +23658,7 @@ class DefaultApi(object):
         :param str project_id:
         :param str creator_id:
         :param str name_contains:
+        :param str image_name_contains:
         :param bool include_archived: Whether to include archived cluster environments in the response.
         :param bool defaults_first: If True, we always return default cluster envs before user created cluster envs. If False, we always return default cluster envs after user created cluster envs. If absent, default to True. Note that we never intersperse default cluster envs with user created cluster envs.
         :param str paging_token:
@@ -23565,6 +23690,7 @@ class DefaultApi(object):
         :param str project_id:
         :param str creator_id:
         :param str name_contains:
+        :param str image_name_contains:
         :param bool include_archived: Whether to include archived cluster environments in the response.
         :param bool defaults_first: If True, we always return default cluster envs before user created cluster envs. If False, we always return default cluster envs after user created cluster envs. If absent, default to True. Note that we never intersperse default cluster envs with user created cluster envs.
         :param str paging_token:
@@ -23589,6 +23715,7 @@ class DefaultApi(object):
             'project_id',
             'creator_id',
             'name_contains',
+            'image_name_contains',
             'include_archived',
             'defaults_first',
             'paging_token',
@@ -23627,6 +23754,8 @@ class DefaultApi(object):
             query_params.append(('creator_id', local_var_params['creator_id']))  # noqa: E501
         if 'name_contains' in local_var_params and local_var_params['name_contains'] is not None:  # noqa: E501
             query_params.append(('name_contains', local_var_params['name_contains']))  # noqa: E501
+        if 'image_name_contains' in local_var_params and local_var_params['image_name_contains'] is not None:  # noqa: E501
+            query_params.append(('image_name_contains', local_var_params['image_name_contains']))  # noqa: E501
         if 'include_archived' in local_var_params and local_var_params['include_archived'] is not None:  # noqa: E501
             query_params.append(('include_archived', local_var_params['include_archived']))  # noqa: E501
         if 'defaults_first' in local_var_params and local_var_params['defaults_first'] is not None:  # noqa: E501
@@ -27326,6 +27455,7 @@ class DefaultApi(object):
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
+        :param list[str] oa_group_names: Search for workspaces that belong to the provided group name
         :param bool for_private_endpoints_homepage: Filters the list to be ones expected for private endpoints home page
         :param bool for_fine_tuning: Filters the list to be ones expected for fine tuning tutorial section
         :param bool for_ai_apps_section: Filters the list to show the ones expected for ai apps section
@@ -27353,6 +27483,7 @@ class DefaultApi(object):
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
+        :param list[str] oa_group_names: Search for workspaces that belong to the provided group name
         :param bool for_private_endpoints_homepage: Filters the list to be ones expected for private endpoints home page
         :param bool for_fine_tuning: Filters the list to be ones expected for fine tuning tutorial section
         :param bool for_ai_apps_section: Filters the list to show the ones expected for ai apps section
@@ -27373,6 +27504,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
+            'oa_group_names',
             'for_private_endpoints_homepage',
             'for_fine_tuning',
             'for_ai_apps_section'
@@ -27400,6 +27532,9 @@ class DefaultApi(object):
         path_params = {}
 
         query_params = []
+        if 'oa_group_names' in local_var_params and local_var_params['oa_group_names'] is not None:  # noqa: E501
+            query_params.append(('oa_group_names', local_var_params['oa_group_names']))  # noqa: E501
+            collection_formats['oa_group_names'] = 'multi'  # noqa: E501
         if 'for_private_endpoints_homepage' in local_var_params and local_var_params['for_private_endpoints_homepage'] is not None:  # noqa: E501
             query_params.append(('for_private_endpoints_homepage', local_var_params['for_private_endpoints_homepage']))  # noqa: E501
         if 'for_fine_tuning' in local_var_params and local_var_params['for_fine_tuning'] is not None:  # noqa: E501