anyscale 0.24.13__tar.gz → 0.24.14__tar.gz

{anyscale-0.24.13 → anyscale-0.24.14}/PKG-INFO

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

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/_private/anyscale_client/anyscale_client.py

@@ -1,8 +1,11 @@
+from abc import ABC, abstractmethod
+import io
 import logging
 import os
 import pathlib
 import time
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, IO, List, Optional, Tuple
+from urllib.parse import urlparse
 
 import requests
 
@@ -60,6 +63,7 @@ from anyscale.util import (
 )
 from anyscale.utils.runtime_env import (
     is_workspace_dependency_tracking_disabled,
+    parse_dot_env_file,
     WORKSPACE_REQUIREMENTS_FILE_PATH,
     zip_local_dir,
 )
@@ -78,6 +82,39 @@ OVERWRITE_EXISTING_CLOUD_STORAGE_FILES = (
 internal_logger = logging.getLogger(__name__)
 
 
+class AWSS3ClientInterface(ABC):
+    @abstractmethod
+    def download_fileobj(self, Bucket: str, Key: str, Fileobj: IO[Any],) -> None:
+        """Download a file from an S3 bucket to a file-like object."""
+        raise NotImplementedError
+
+
+class GCSBlobInterface(ABC):
+    @abstractmethod
+    def download_to_file(self, fileobj: IO[Any]) -> None:
+        """Download the blob to a file-like object."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def exists(self) -> bool:
+        """Check if the blob exists."""
+        raise NotImplementedError
+
+
+class GCSBucketInterface(ABC):
+    @abstractmethod
+    def blob(self, object_name: str) -> GCSBlobInterface:
+        """Get a blob object for the given object name."""
+        raise NotImplementedError
+
+
+class GCPGCSClientInterface(ABC):
+    @abstractmethod
+    def bucket(self, bucket: str) -> GCSBucketInterface:
+        """Get a bucket object for the given bucket name."""
+        raise NotImplementedError
+
+
 class AnyscaleClient(AnyscaleClientInterface):
     # Number of entries to fetch per request for list endpoints.
     LIST_ENDPOINT_COUNT = 50
@@ -90,6 +127,8 @@ class AnyscaleClient(AnyscaleClientInterface):
         workspace_requirements_file_path: str = WORKSPACE_REQUIREMENTS_FILE_PATH,
         logger: Optional[BlockLogger] = None,
         host: Optional[str] = None,
+        s3_client: Optional[AWSS3ClientInterface] = None,
+        gcs_client: Optional[GCPGCSClientInterface] = None,
     ):
         if api_clients is None:
             auth_block: AuthenticationBlock = get_auth_api_client(
@@ -100,6 +139,8 @@ class AnyscaleClient(AnyscaleClientInterface):
         self._external_api_client, self._internal_api_client = api_clients
         self._workspace_requirements_file_path = workspace_requirements_file_path
         self._sleep = sleep or time.sleep
+        self._s3_client = s3_client
+        self._gcs_client = gcs_client
 
         # Cached IDs and models to avoid duplicate lookups.
         self._default_project_id: Optional[str] = None
@@ -108,6 +149,35 @@ class AnyscaleClient(AnyscaleClientInterface):
         self._logger = logger or BlockLogger()
         self._host = host or ANYSCALE_HOST
 
+    @property
+    def s3_client(self) -> AWSS3ClientInterface:
+        if self._s3_client is None:
+            # initialize the s3 client lazily so that we import the boto3 library only when needed.
+            try:
+                import boto3
+                import botocore.config
+            except ImportError:
+                raise RuntimeError(
+                    "Could not import the Amazon S3 Python API via `import boto3`.  Please check your installation or try running `pip install boto3`."
+                )
+            self._s3_client = boto3.client(
+                "s3", config=botocore.config.Config(signature_version="s3v4")
+            )  # type: ignore
+        return self._s3_client  # type: ignore
+
+    @property
+    def gcs_client(self) -> GCPGCSClientInterface:
+        if self._gcs_client is None:
+            # initialize the gcs client lazily so that we import the google cloud storage library only when needed.
+            try:
+                from google.cloud import storage
+            except ImportError:
+                raise RuntimeError(
+                    "Could not import the Google Storage Python API via `from google.cloud import storage`.  Please check your installation or try running `pip install --upgrade google-cloud-storage`."
+                )
+            self._gcs_client = storage.Client()
+        return self._gcs_client  # type: ignore
+
     @property
     def host(self) -> str:
         return self._host
@@ -143,6 +213,82 @@ class AnyscaleClient(AnyscaleClientInterface):
 
         return self._workspace_requirements_file_path
 
+    def _download_file_from_google_cloud_storage(
+        self, bucket: str, object_name: str
+    ) -> Optional[bytes]:
+        try:
+            bucket_obj = self.gcs_client.bucket(bucket)
+            blob = bucket_obj.blob(object_name)
+            fileobj = io.BytesIO()
+            if blob.exists():
+                blob.download_to_file(fileobj)
+                return fileobj.getvalue()
+            return None
+        except Exception as e:  # noqa: BLE001
+            raise RuntimeError(
+                f"Failed to download the working directory from Google Cloud Storage. Error {repr(e)}"
+                "Please validate you have exported cloud credentials with the correct read permissions and the intended bucket exists in your Cloud Storage account. "
+            ) from e
+
+    def _download_file_from_s3(self, bucket: str, object_key: str) -> Optional[bytes]:
+        try:
+            from botocore.exceptions import ClientError
+        except Exception:  # noqa: BLE001
+            raise RuntimeError(
+                "Could not download file from S3: Could not import the Amazon S3 Python API via `import boto3`.  Please check your installation or try running `pip install boto3`."
+            )
+        try:
+            fileobj = io.BytesIO()
+            print("downloading", bucket, object_key)
+            self.s3_client.download_fileobj(bucket, object_key, fileobj)
+            return fileobj.getvalue()
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "404":
+                return None
+            raise
+        except Exception as e:  # noqa: BLE001
+            raise RuntimeError(
+                f"Failed to download the working directory from S3. Error {repr(e)}"
+                "Please validate you have exported cloud credentials with the correct read permissions and the intended bucket exists in your S3 account. "
+            ) from e
+
+    def _download_file_from_remote_storage(self, remote_uri: str) -> Optional[bytes]:
+        parsed_uri = urlparse(remote_uri)
+        service = parsed_uri.scheme
+        bucket = parsed_uri.netloc
+        object_name = parsed_uri.path.lstrip("/")
+        if service == "s3":
+            return self._download_file_from_s3(bucket, object_name)
+        if service == "gs":
+            return self._download_file_from_google_cloud_storage(bucket, object_name)
+        return None
+
+    def get_workspace_env_vars(self) -> Optional[Dict[str, str]]:
+        system_storage_path = os.environ.get("ANYSCALE_INTERNAL_SYSTEM_STORAGE", "")
+        workspace_id = os.environ.get("ANYSCALE_EXPERIMENTAL_WORKSPACE_ID", "")
+        workspace_artifact_path = (
+            os.path.join(
+                system_storage_path,
+                ".anyscale/workspace_tracking_requirements",
+                workspace_id,
+            )
+            if workspace_id and system_storage_path
+            else ""
+        )
+        workspace_dot_env_path = (
+            os.path.join(workspace_artifact_path, ".env")
+            if workspace_artifact_path
+            else ""
+        )
+
+        if not self.inside_workspace() or not workspace_dot_env_path:
+            return None
+
+        dot_env = self._download_file_from_remote_storage(workspace_dot_env_path)
+        if dot_env:
+            return parse_dot_env_file(dot_env)
+        return None
+
     def get_current_workspace_cluster(self) -> Optional[Cluster]:
         # Checks for the existence of the ANYSCALE_EXPERIMENTAL_WORKSPACE_ID env var.
         if not is_anyscale_workspace():
@@ -156,13 +302,20 @@ class AnyscaleClient(AnyscaleClientInterface):
 
         return self._current_workspace_cluster
 
-    def get_project_id(self) -> str:
+    def get_project_id(self, parent_cloud_id: str) -> str:
         workspace_cluster = self.get_current_workspace_cluster()
         if workspace_cluster is not None:
             return workspace_cluster.project_id
 
         if self._default_project_id is None:
-            default_project: Project = self._external_api_client.get_default_project().result
+            # Cloud isolation organizations follow the permissions model in https://docs.anyscale.com/organization-and-user-account/access-controls
+            # TODO(nikita): Remove this FF check after completing the cloud isolation migration in Q2 2024
+            cloud_isolation_ff_on = self._internal_api_client.check_is_feature_flag_on_api_v2_userinfo_check_is_feature_flag_on_get(
+                "cloud-isolation-phase-1"
+            ).result.is_on
+            default_project: Project = self._external_api_client.get_default_project(
+                parent_cloud_id=(parent_cloud_id if cloud_isolation_ff_on else None)
+            ).result
             self._default_project_id = default_project.id
 
         return self._default_project_id
@@ -544,7 +697,8 @@ class AnyscaleClient(AnyscaleClientInterface):
         # TODO(edoakes): this endpoint is very slow and there's no reason we should need
         # to use this complex list endpoint just to fetch a service by name.
         paging_token = None
-        project_id = self.get_project_id()
+        cloud_id = self.get_cloud_id()
+        project_id = self.get_project_id(parent_cloud_id=cloud_id)
         service: Optional[ServiceModel] = None
         while True:
             resp = self._external_api_client.list_services(

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/_private/anyscale_client/common.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from anyscale._private.models.image_uri import ImageURI
 from anyscale.client.openapi_client.models import (
@@ -59,6 +59,11 @@ class AnyscaleClientInterface(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_workspace_env_vars(self) -> Optional[Dict[str, str]]:
+        """Returns the environment variables specified in workspace runtime dependencies."""
+        raise NotImplementedError
+
     @abstractmethod
     def get_current_workspace_cluster(self) -> Optional[Cluster]:
         """Get the cluster model for the workspace this code is running in.
@@ -75,7 +80,7 @@ class AnyscaleClientInterface(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_project_id(self) -> str:
+    def get_project_id(self, parent_cloud_id: str) -> str:
         """Get the default project ID for this user.
 
         If running in a workspace, returns the workspace project ID.

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -71,6 +71,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._requirements_path: Optional[str] = None
         self._upload_uri_mapping: Dict[str, str] = {}
         self._submitted_job: Optional[CreateInternalProductionJob] = None
+        self._env_vars: Optional[Dict[str, str]] = None
 
         # Cloud ID -> Cloud.
         self._clouds: Dict[str, Cloud] = {
@@ -110,8 +111,10 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         *,
         requirements_path: Optional[str] = None,
         cluster_name: Optional[str] = None,
+        env_vars: Optional[Dict[str, str]] = None,
     ):
         self._requirements_path = requirements_path
+        self._env_vars = env_vars
         if inside_workspace:
             self._workspace_cluster = Cluster(
                 id=self.WORKSPACE_CLUSTER_ID,
@@ -136,6 +139,9 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     def inside_workspace(self) -> bool:
         return self.get_current_workspace_cluster() is not None
 
+    def get_workspace_env_vars(self) -> Optional[Dict[str, str]]:
+        return self._env_vars
+
     def get_workspace_requirements_path(self) -> Optional[str]:
         if self.inside_workspace():
             return self._requirements_path
@@ -152,7 +158,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         if self.inside_workspace():
             self._sent_workspace_notifications.append(notification)
 
-    def get_project_id(self) -> str:
+    def get_project_id(self, parent_cloud_id: str) -> str:  # noqa: ARG002
         workspace_cluster = self.get_current_workspace_cluster()
         if workspace_cluster is not None:
             return workspace_cluster.project_id

anyscale-0.24.14/anyscale/_private/models/__init__.py

@@ -0,0 +1,2 @@
+from anyscale._private.models.image_uri import ImageURI
+from anyscale._private.models.model_base import ModelBase, ModelEnum

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/_private/models/model_base.py

@@ -1,5 +1,5 @@
 from dataclasses import asdict, fields
-from enum import Enum
+from enum import Enum, EnumMeta
 import inspect
 from typing import Any, Dict, Iterable, Tuple, TypeVar
 
@@ -11,7 +11,42 @@ import yaml
 TModelBase = TypeVar("TModelBase", bound="ModelBase")
 
 
-class ModelBase:
+class ModelEnumType(EnumMeta):
+    def __new__(cls, subcls, bases, classdict):
+        cls = super().__new__(cls, subcls, bases, classdict)
+
+        # Assert that all enum values have docstrings.
+        if not isinstance(cls.__docstrings__, dict) or not all(
+            isinstance(k, str) and isinstance(v, str)
+            for k, v in cls.__docstrings__.items()
+        ):
+            raise TypeError(
+                f"ModelEnum '{cls.__name__}.__docstrings__' is the wrong type. "
+                "Must be a Dict[ModelEnum, str] documenting all enum values"
+            )
+
+        missing = {v.value for v in cls} - set(cls.__docstrings__.keys())
+        if missing:
+            raise TypeError(
+                f"ModelEnum '{cls.__name__}.__docstrings__' is missing docstrings for values: {missing}"
+            )
+
+        return cls
+
+
+class ModelEnum(str, Enum, metaclass=ModelEnumType):
+    # Must be populated by subclasses to document every value.
+    __docstrings__: Dict["ModelEnum", str] = {}
+
+    def __str__(self):
+        return self.name
+
+
+class ModelBaseType(type):
+    pass
+
+
+class ModelBase(metaclass=ModelBaseType):
     def __new__(cls, *args, **kwargs):  # noqa: ARG003
         """Validate that the subclass is a conforming dataclass."""
         if (
@@ -34,6 +69,11 @@ class ModelBase:
         returned value.
         """
         for field in fields(self):
+            if not field.metadata.get("docstring", None):
+                raise ValueError(
+                    f"Model '{type(self).__name__}' is missing docstring for field '{field.name}'."
+                )
+
             validator = getattr(self, f"_validate_{field.name}", None)
             if validator is None:
                 raise RuntimeError(
@@ -92,7 +132,7 @@ class ModelBase:
                     continue
 
                 # Convert enums to their string representation.
-                if isinstance(v, Enum):
+                if isinstance(v, ModelEnum):
                     v = v.value
 
                 d[k] = v

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/_private/workload/workload_config.py

@@ -7,13 +7,20 @@ from anyscale.compute_config.models import ComputeConfig
 
 @dataclass(frozen=True)
 class WorkloadConfig(ModelBase):
-    name: Optional[str] = field(default=None)
+    name: Optional[str] = field(
+        default=None, metadata={"docstring": "Should be overwritten by subclass."}
+    )
 
     def _validate_name(self, name: Optional[str]):
         if name is not None and not isinstance(name, str):
             raise TypeError("'name' must be a string.")
 
-    image_uri: Optional[str] = field(default=None)
+    image_uri: Optional[str] = field(
+        default=None,
+        metadata={
+            "docstring": "URI of an existing image. Exclusive with `containerfile`."
+        },
+    )
 
     def _validate_image_uri(self, image_uri: Optional[str]):
         if image_uri is not None and not isinstance(image_uri, str):
@@ -21,13 +28,24 @@ class WorkloadConfig(ModelBase):
         if image_uri is not None:
             ImageURI.from_str(image_uri)
 
-    containerfile: Optional[str] = field(default=None, repr=False)
+    containerfile: Optional[str] = field(
+        default=None,
+        repr=False,
+        metadata={
+            "docstring": "String representation of a containerfile that will be built into an image before running the workload. Exclusive with `image_uri`."
+        },
+    )
 
     def _validate_containerfile(self, containerfile: Optional[str]):
         if containerfile is not None and not isinstance(containerfile, str):
             raise TypeError("'containerfile' must be a string.")
 
-    compute_config: Union[None, str, Dict, ComputeConfig] = field(default=None)
+    compute_config: Union[None, str, Dict, ComputeConfig] = field(
+        default=None,
+        metadata={
+            "docstring": "The name of an existing registered compute config or an inlined ComputeConfig object."
+        },
+    )
 
     def _validate_compute_config(
         self, compute_config: Union[None, str, Dict, ComputeConfig]
@@ -44,13 +62,25 @@ class WorkloadConfig(ModelBase):
 
         return compute_config
 
-    working_dir: Optional[str] = field(default=None, repr=False)
+    working_dir: Optional[str] = field(
+        default=None,
+        repr=False,
+        metadata={
+            "docstring": "Directory that will be used as the working directory for the application. If a local directory is provided, it will be uploaded to cloud storage automatically. When running inside a workspace, this defaults to the current working directory ('.')."
+        },
+    )
 
     def _validate_working_dir(self, working_dir: Optional[str]):
         if working_dir is not None and not isinstance(working_dir, str):
             raise TypeError("'working_dir' must be a string.")
 
-    excludes: Optional[List[str]] = field(default=None, repr=False)
+    excludes: Optional[List[str]] = field(
+        default=None,
+        repr=False,
+        metadata={
+            "docstring": "A list of file path globs that will be excluded when uploading local files for `working_dir`."
+        },
+    )
 
     def _validate_excludes(self, excludes: Optional[List[str]]):
         if excludes is not None and (
@@ -59,7 +89,13 @@ class WorkloadConfig(ModelBase):
         ):
             raise TypeError("'excludes' must be a list of strings.")
 
-    requirements: Optional[Union[str, List[str]]] = field(default=None, repr=False)
+    requirements: Optional[Union[str, List[str]]] = field(
+        default=None,
+        repr=False,
+        metadata={
+            "docstring": "A list of requirements or a path to a `requirements.txt` file for the workload. When running inside a workspace, this defaults to the workspace-tracked requirements."
+        },
+    )
 
     def _validate_requirements(self, requirements: Optional[Union[str, List[str]]]):
         if requirements is None or isinstance(requirements, str):
@@ -71,3 +107,20 @@ class WorkloadConfig(ModelBase):
             raise TypeError(
                 "'requirements' must be a string (file path) or list of strings."
             )
+
+    env_vars: Optional[Dict[str, str]] = field(
+        default=None,
+        repr=True,
+        metadata={
+            "docstring": "A dictionary of environment variables that will be set for the workload."
+        },
+    )
+
+    def _validate_env_vars(self, env_vars: Optional[Dict[str, str]]):
+        if env_vars is not None and (
+            not isinstance(env_vars, dict)
+            or not all(
+                isinstance(k, str) and isinstance(v, str) for k, v in env_vars.items()
+            )
+        ):
+            raise TypeError("'env_vars' must be a Dict[str, str].")

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/_private/workload/workload_sdk.py

@@ -40,6 +40,25 @@ class WorkloadSDK(BaseSDK):
     def enable_image_build_for_tracked_requirements(self) -> bool:
         return self._enable_image_build_for_tracked_requirements
 
+    def update_env_vars(
+        self,
+        runtime_envs: List[Dict[str, Any]],
+        *,
+        env_vars_updates: Optional[Dict[str, str]],
+    ) -> List[Dict[str, Any]]:
+        """Replaces 'env_vars' fields in runtime_envs with the override."""
+        new_runtime_envs = copy.deepcopy(runtime_envs)
+
+        if env_vars_updates:
+            for runtime_env in new_runtime_envs:
+                if "env_vars" in runtime_env:
+                    # the precedence should be config > runtime_env
+                    runtime_env["env_vars"].update(env_vars_updates)
+                else:
+                    runtime_env["env_vars"] = env_vars_updates
+
+        return new_runtime_envs
+
     def override_and_load_requirements_files(
         self,
         runtime_envs: List[Dict[str, Any]],

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/commands/job_commands.py

@@ -7,6 +7,7 @@ import click
 import anyscale
 from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client import HaJobStates
+from anyscale.commands.util import convert_kv_strings_to_dict
 from anyscale.controllers.job_controller import JobController
 from anyscale.job.models import JobConfig
 from anyscale.util import validate_non_negative_arg
@@ -66,6 +67,13 @@ def job_cli() -> None:
     type=str,
     help="Path to a containerfile to build the image to use for the job. This is exclusive with --image-uri.",
 )
+@click.option(
+    "--env",
+    required=False,
+    multiple=True,
+    type=str,
+    help="Environment variables to set for the job. The format is key=value. This argument can be specified multiple times.",
+)
 @click.argument("entrypoint", required=False, nargs=-1, type=click.UNPROCESSED)
 def submit(  # noqa: PLR0912 PLR0913 C901
     entrypoint: Tuple[str],
@@ -76,29 +84,37 @@ def submit(  # noqa: PLR0912 PLR0913 C901
     config_file: Optional[str],
     image_uri: Optional[str],
     containerfile: Optional[str],
+    env: Tuple[str],
 ):
     """Submit a job.
 
     The job config can be specified in one of the following ways:
-    * Job config can be specified with command-line arguments. In this case, the
-      entrypoint should be specified as the positional arguments starting with `--`.
-      Other arguments can be specified with command-line flags. E.g.
+
+    * Job config file can be specified as a single positional argument. E.g. `anyscale job submit config.yaml`.
+
+    * Job config can also be specified with command-line arguments. In this case, the entrypoint should be specified
+as the positional arguments starting with `--`. Other arguments can be specified with command-line flags. E.g.
+
       * `anyscale job submit -- python main.py`: submit a job with the entrypoint `python main.py`.
+
       * `anyscale job submit --name my-job -- python main.py`: submit a job with the name `my-job` and the
-        entrypoint `python main.py`.
-    * Job config can also be specified in a YAML file with the `--config-file` flag.
-      In this case, you can still override arguments with command-line flags. E.g.
+entrypoint `python main.py`.
+
+    * [Experimental] If you want to specify a config file and override some arguments with the commmand-line flags,
+use the `--config-file` flag. E.g.
+
       * `anyscale job submit --config-file config.yaml`: submit a job with the config in `config.yaml`.
+
       * `anyscale job submit --config-file config.yaml -- python main.py`: submit a job with the config in `config.yaml`
-        and override the entrypoint with `python main.py`.
-    * [Deprecated] If the positional argument is a single string that ends with .yaml, this is treated as a config file.
-      E.g. `anyscale job submit config.yaml`.
+and override the entrypoint with `python main.py`.
 
     By default, this command submits the job asynchronously and exits. To wait for the job to complete, use the `--wait` flag.
     """
 
     job_controller = JobController()
-    if len(entrypoint) == 1 and entrypoint[0].endswith(".yaml"):
+    if len(entrypoint) == 1 and (
+        pathlib.Path(entrypoint[0]).is_file() or entrypoint[0].endswith(".yaml")
+    ):
         # If entrypoint is a single string that ends with .yaml, e.g. `anyscale job submit config.yaml`,
         # treat it as a config file, and use the old job submission API.
         if config_file is not None:
@@ -113,6 +129,10 @@ def submit(  # noqa: PLR0912 PLR0913 C901
             raise click.ClickException(
                 "`--containerfile` should not be used when providing a config file as the entrypoint."
             )
+        if env:
+            raise click.ClickException(
+                "`--env` should not be used when providing a config file as the entrypoint."
+            )
 
         config_file = entrypoint[0]
         if not pathlib.Path(config_file).is_file():
@@ -156,6 +176,10 @@ def submit(  # noqa: PLR0912 PLR0913 C901
             config = JobConfig.from_yaml(config_file, **args)
         else:
             config = JobConfig.from_dict(args)
+        if env:
+            env_dict = convert_kv_strings_to_dict(env)
+            if env_dict:
+                config = config.options(env_vars=env_dict)
         log.info(f"Submitting job with config {config}.")
         job_id = anyscale.job.submit(config)
 

{anyscale-0.24.13 → anyscale-0.24.14}/anyscale/commands/service_commands.py

@@ -8,6 +8,7 @@ from typing_extensions import Literal
 import yaml
 
 from anyscale.cli_logger import BlockLogger
+from anyscale.commands.util import convert_kv_strings_to_dict
 from anyscale.controllers.service_controller import ServiceController
 import anyscale.service
 from anyscale.service import ServiceConfig, ServiceStatus
@@ -22,26 +23,6 @@ def service_cli():
     pass
 
 
-def _convert_arguments_to_dict(args: Tuple[str]) -> Dict[str, str]:
-    """Convert args of the form "key=val" into a dictionary of {key: val}.
-
-    NOTE(edoakes): this mimics the functionality of the `serve run` CLI and should be
-    kept in sync with it.
-    """
-    args_dict = {}
-    for arg in args:
-        split = arg.split("=")
-        if len(split) != 2:
-            raise click.ClickException(
-                f"Invalid application argument '{arg}', "
-                "must be of the form '<key>=<val>'."
-            )
-
-        args_dict[split[0]] = split[1]
-
-    return args_dict
-
-
 def _read_name_from_config_file(path: str):
     """Read the 'name' property from the config file at `path`.
 
@@ -148,6 +129,13 @@ def _read_name_from_config_file(path: str):
     type=int,
     help="Amount of excess capacity allowed to be used while updating the service (0-100). Defaults to 100. Not supported when using --in-place.",
 )
+@click.option(
+    "--env",
+    required=False,
+    multiple=True,
+    type=str,
+    help="Environment variables to set for the job. The format is key=value. This argument can be specified multiple times.",
+)
 def deploy(  # noqa: PLR0912, PLR0913
     config_file: Optional[str],
     import_path: Optional[str],
@@ -162,6 +150,7 @@ def deploy(  # noqa: PLR0912, PLR0913
     in_place: bool,
     canary_percent: Optional[int],
     max_surge_percent: Optional[int],
+    env: Optional[Tuple[str]],
 ):
     """Deploy or update a service.
 
@@ -203,7 +192,7 @@ t
             )
 
         app: Dict[str, Any] = {"import_path": import_path}
-        arguments_dict = _convert_arguments_to_dict(arguments)
+        arguments_dict = convert_kv_strings_to_dict(arguments)
         if arguments_dict:
             app["arguments"] = arguments_dict
 
@@ -235,6 +224,11 @@ t
     if requirements is not None:
         config = config.options(requirements=requirements)
 
+    if env:
+        env_dict = convert_kv_strings_to_dict(env)
+        if env_dict:
+            config = config.options(env_vars=env_dict)
+
     anyscale.service.deploy(
         config,
         in_place=in_place,