anyscale 0.24.86__py3-none-any.whl

anyscale/schedule/_private/schedule_sdk.py

@@ -0,0 +1,165 @@
+from typing import Optional
+
+from anyscale._private.anyscale_client.common import AnyscaleClientInterface
+from anyscale._private.sdk.base_sdk import BaseSDK, Timer
+from anyscale.cli_logger import BlockLogger
+from anyscale.client.openapi_client.models.create_schedule import CreateSchedule
+from anyscale.client.openapi_client.models.decorated_schedule import DecoratedSchedule
+from anyscale.client.openapi_client.models.production_job_config import (
+    ProductionJobConfig,
+)
+from anyscale.client.openapi_client.models.schedule_config import (
+    ScheduleConfig as BackendScheduleConfig,
+)
+from anyscale.job._private.job_sdk import PrivateJobSDK
+from anyscale.job.models import JobConfig
+from anyscale.schedule.models import ScheduleConfig, ScheduleState, ScheduleStatus
+
+
+logger = BlockLogger()
+
+
+class PrivateScheduleSDK(BaseSDK):
+    def __init__(
+        self,
+        *,
+        logger: Optional[BlockLogger] = None,
+        client: Optional[AnyscaleClientInterface] = None,
+        timer: Optional[Timer] = None,
+    ):
+        super().__init__(logger=logger, client=client, timer=timer)
+        self._job_sdk = PrivateJobSDK(logger=self.logger, client=self.client)
+
+    def apply(self, config: ScheduleConfig) -> str:
+        job_config = config.job_config
+        assert isinstance(job_config, JobConfig)
+        name = job_config.name or self._job_sdk.get_default_name()
+
+        compute_config_id, cloud_id = self._job_sdk.resolve_compute_config_and_cloud_id(
+            compute_config=job_config.compute_config, cloud=job_config.cloud
+        )
+
+        project_id = self.client.get_project_id(
+            parent_cloud_id=cloud_id, name=job_config.project
+        )
+
+        schedule: DecoratedSchedule = self.client.apply_schedule(
+            CreateSchedule(
+                name=name,
+                project_id=project_id,
+                config=self._job_sdk.job_config_to_internal_prod_job_conf(
+                    config=job_config,
+                    name=name,
+                    cloud_id=cloud_id,
+                    compute_config_id=compute_config_id,
+                ),
+                schedule=BackendScheduleConfig(
+                    cron_expression=config.cron_expression, timezone=config.timezone,
+                ),
+            )
+        )
+
+        self.logger.info(f"Schedule '{name}' submitted, ID: '{schedule.id}'.")
+
+        return schedule.id
+
+    def _resolve_to_schedule_model(
+        self,
+        *,
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+        id: Optional[str] = None,  # noqa: A002
+    ) -> DecoratedSchedule:
+        if name is None and id is None:
+            raise ValueError("One of 'name' or 'id' must be provided.")
+
+        if name is not None and id is not None:
+            raise ValueError("Only one of 'name' or 'id' can be provided.")
+
+        if id is not None and (cloud is not None or project is not None):
+            raise ValueError("'cloud' and 'project' should only be used with 'name'.")
+
+        model: Optional[DecoratedSchedule] = self.client.get_schedule(
+            name=name, id=id, cloud=cloud, project=project,
+        )
+
+        if model is None:
+            if name is not None:
+                raise RuntimeError(f"Schedule with name '{name}' was not found.")
+            else:
+                raise RuntimeError(f"Schedule with ID '{id}' was not found.")
+
+        return model
+
+    def set_state(
+        self,
+        *,
+        id: Optional[str] = None,  # noqa: A002
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+        state: ScheduleState,
+    ) -> str:
+        schedule_model = self._resolve_to_schedule_model(
+            name=name, id=id, cloud=cloud, project=project
+        )
+        is_paused = state == ScheduleState.DISABLED
+        self.client.set_schedule_state(id=schedule_model.id, is_paused=is_paused)
+        self.logger.info(f"Set schedule '{schedule_model.name}' to state {state}")
+        return schedule_model.id
+
+    def _schedule_model_to_status(self, model: DecoratedSchedule) -> ScheduleStatus:
+        project_model = self.client.get_project(model.project_id)
+        project = (
+            project_model.name
+            if project_model is not None and project_model.name != "default"
+            else None
+        )
+
+        prod_job_config: ProductionJobConfig = model.config
+        job_config = self._job_sdk.prod_job_config_to_job_config(
+            prod_job_config=prod_job_config, name=model.name, project=project
+        )
+
+        config = ScheduleConfig(
+            job_config=job_config,
+            cron_expression=model.schedule.cron_expression,
+            timezone=model.schedule.timezone,
+        )
+
+        state = (
+            ScheduleState.ENABLED
+            if model.next_trigger_at is not None
+            else ScheduleState.DISABLED
+        )
+
+        return ScheduleStatus(id=model.id, name=model.name, config=config, state=state)
+
+    def status(
+        self,
+        *,
+        id: Optional[str] = None,  # noqa: A002
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+    ) -> ScheduleStatus:
+        schedule_model = self._resolve_to_schedule_model(
+            name=name, id=id, cloud=cloud, project=project
+        )
+        return self._schedule_model_to_status(model=schedule_model)
+
+    def trigger(
+        self,
+        *,
+        id: Optional[str] = None,  # noqa: A002
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+    ) -> str:
+        schedule_model = self._resolve_to_schedule_model(
+            name=name, id=id, cloud=cloud, project=project
+        )
+        self.client.trigger_schedule(id=schedule_model.id)
+        self.logger.info(f"Triggered job for schedule '{schedule_model.name}'.")
+        return schedule_model.id

anyscale/schedule/commands.py

@@ -0,0 +1,149 @@
+from typing import Optional
+
+from anyscale._private.sdk import sdk_command
+from anyscale.cli_logger import BlockLogger
+from anyscale.schedule._private.schedule_sdk import PrivateScheduleSDK
+from anyscale.schedule.models import ScheduleConfig, ScheduleState, ScheduleStatus
+
+
+logger = BlockLogger()
+
+_SCHEDULE_SDK_SINGLETON_KEY = "schedule_sdk"
+
+_APPLY_EXAMPLE = """
+import anyscale
+from anyscale.job.models import JobConfig
+from anyscale.schedule.models import ScheduleConfig
+
+anyscale.schedule.apply(
+    ScheduleConfig(
+        cron_expression="0 0 * * * *",
+        job_config=JobConfig(
+            name="my-job",
+            entrypoint="python main.py",
+            working_dir=".",
+        )
+    )
+)
+"""
+
+_APPLY_ARG_DOCSTRINGS = {"config": "The config options defining the schedule."}
+
+
+@sdk_command(
+    _SCHEDULE_SDK_SINGLETON_KEY,
+    PrivateScheduleSDK,
+    doc_py_example=_APPLY_EXAMPLE,
+    arg_docstrings=_APPLY_ARG_DOCSTRINGS,
+)
+def apply(config: ScheduleConfig, *, _sdk: PrivateScheduleSDK) -> str:
+    """Apply or update a schedule.
+
+    Returns the id of the schedule.
+    """
+    return _sdk.apply(config)
+
+
+_SET_STATE_EXAMPLE = """
+import anyscale
+from anyscale.schedule.models import ScheduleState
+
+anyscale.schedule.set_state(
+    id="my=schedule-id",
+    state=ScheduleState.DISABLED,
+)
+"""
+
+_SET_STATE_ARG_DOCSTRINGS = {
+    "id": "The id of the schedule.",
+    "name": "The name of the schedule.",
+    "cloud": "The Anyscale Cloud to run this workload on. If not provided, the organization default will be used (or, if running in a workspace, the cloud of the workspace).",
+    "project": "Named project to use for the job. If not provided, the default project for the cloud will be used (or, if running in a workspace, the project of the workspace).",
+    "state": "The state to set the schedule to.",
+}
+
+
+@sdk_command(
+    _SCHEDULE_SDK_SINGLETON_KEY,
+    PrivateScheduleSDK,
+    doc_py_example=_SET_STATE_EXAMPLE,
+    arg_docstrings=_SET_STATE_ARG_DOCSTRINGS,
+)
+def set_state(
+    *,
+    id: Optional[str] = None,  # noqa: A002
+    name: Optional[str] = None,
+    cloud: Optional[str] = None,
+    project: Optional[str] = None,
+    state: ScheduleState,
+    _sdk: PrivateScheduleSDK
+) -> str:
+    """Set the state of a schedule.
+
+    Returns the id of the schedule.
+    """
+    return _sdk.set_state(id=id, name=name, cloud=cloud, project=project, state=state,)
+
+
+_STATUS_EXAMPLE = """
+import anyscale
+anyscale.schedule.status(id="cronjob_yt389jvskwht9k2ygx7rj6iz62")
+"""
+
+_STATUS_ARG_DOCSTRINGS = {
+    "id": "The id of the schedule.",
+    "name": "The name of the schedule.",
+    "cloud": "The Anyscale Cloud to run this workload on. If not provided, the organization default will be used (or, if running in a workspace, the cloud of the workspace).",
+    "project": "Named project to use for the job. If not provided, the default project for the cloud will be used (or, if running in a workspace, the project of the workspace).",
+}
+
+
+@sdk_command(
+    _SCHEDULE_SDK_SINGLETON_KEY,
+    PrivateScheduleSDK,
+    doc_py_example=_STATUS_EXAMPLE,
+    arg_docstrings=_STATUS_ARG_DOCSTRINGS,
+)
+def status(
+    *,
+    id: Optional[str] = None,  # noqa: A002
+    name: Optional[str] = None,
+    cloud: Optional[str] = None,
+    project: Optional[str] = None,
+    _sdk: PrivateScheduleSDK
+) -> ScheduleStatus:
+    """Return the status of the schedule.
+    """
+    return _sdk.status(id=id, name=name, cloud=cloud, project=project)
+
+
+_TRIGGER_EXAMPLE = """
+import anyscale
+anyscale.schedule.trigger(id="cronjob_yt389jvskwht9k2ygx7rj6iz62")
+"""
+
+_TRIGGER_ARG_DOCSTRINGS = {
+    "id": "The id of the schedule.",
+    "name": "The name of the schedule.",
+    "cloud": "The Anyscale Cloud to run this workload on. If not provided, the organization default will be used (or, if running in a workspace, the cloud of the workspace).",
+    "project": "Named project to use for the job. If not provided, the default project for the cloud will be used (or, if running in a workspace, the project of the workspace).",
+}
+
+
+@sdk_command(
+    _SCHEDULE_SDK_SINGLETON_KEY,
+    PrivateScheduleSDK,
+    doc_py_example=_TRIGGER_EXAMPLE,
+    arg_docstrings=_TRIGGER_ARG_DOCSTRINGS,
+)
+def trigger(
+    *,
+    id: Optional[str] = None,  # noqa: A002
+    name: Optional[str] = None,
+    cloud: Optional[str] = None,
+    project: Optional[str] = None,
+    _sdk: PrivateScheduleSDK
+) -> str:
+    """Trigger the execution of the schedule.
+    """
+    return _sdk.trigger(id=id, name=name, cloud=cloud, project=project)

anyscale/schedule/models.py

@@ -0,0 +1,145 @@
+from dataclasses import dataclass, field
+from typing import Dict, Union
+
+import tzlocal
+
+from anyscale._private.models import ModelBase, ModelEnum
+from anyscale.job.models import JobConfig
+
+
+UTC_TZ_NAME = "UTC"
+
+
+@dataclass(frozen=True)
+class ScheduleConfig(ModelBase):
+    """Configuration options for a schedule."""
+
+    __doc_py_example__ = """\
+from anyscale.schedule.models import ScheduleConfig
+from anyscale.job.models import JobConfig
+
+config = ScheduleConfig(
+    job_config=JobConfig(
+        entrypoint="python main.py"
+    ),
+    timezone="local",
+    cron_expression="0 0 * * *"
+)
+"""
+
+    __doc_yaml_example__ = """\
+timezone: local
+cron_expression: 0 0 * * * *
+job_config:
+    name: my-schedule-job
+    entrypoint: python main.py
+    max_retries: 5
+"""
+
+    job_config: Union[Dict, JobConfig] = field(
+        metadata={"docstring": "Configuration of the job."}
+    )
+
+    def _validate_job_config(self, job_config: Union[Dict, JobConfig]) -> JobConfig:
+        if isinstance(job_config, dict):
+            job_config = JobConfig.from_dict(job_config)
+
+        if not isinstance(job_config, JobConfig):
+            raise TypeError("'job_config' must be a JobConfig.")
+
+        return job_config
+
+    cron_expression: str = field(
+        metadata={
+            "docstring": "A cron expression to define the frequency at which to run this cron job, for example '0 0 * * *' is a cron expression that means 'run at midnight'. Visit crontab.guru to construct a precise cron_expression."
+        }
+    )
+
+    def _validate_cron_expression(self, cron_expression: str):
+        # validation of cron expression is primarily handled by the backend when
+        # applying the schedule. simply check if it is a non-empty string here.
+        if not isinstance(cron_expression, str):
+            raise TypeError("'cron_expression' must be a string.")
+
+        if not cron_expression:
+            raise ValueError("'cron_expression' cannot be empty.")
+
+    timezone: str = field(
+        default=UTC_TZ_NAME,
+        metadata={
+            "docstring": "The timezone in which to interpret the cron_expression. Default is Universal time (UTC). You can specify 'local' to use the local timezone"
+        },
+    )
+
+    def _validate_timezone(self, timezone: str) -> str:
+        # validation of timezone is primarily handled by the backend when
+        # applying the schedule. simply check if it is a non-empty string here.
+        if not isinstance(timezone, str):
+            raise TypeError("'timezone' must be a string.")
+        if not timezone:
+            raise ValueError("'timezone' cannot be empty.")
+        elif timezone == "local":
+            return tzlocal.get_localzone_name()
+        else:
+            return timezone
+
+
+class ScheduleState(ModelEnum):
+    """Current state of a schedule."""
+
+    ENABLED = "ENABLED"
+    DISABLED = "DISABLED"
+
+    __docstrings__ = {
+        ENABLED: "The schedule is enabled. Jobs will be started according to this jobs cron expression.",
+        DISABLED: "The schedule is disabled. No jobs will be started until the schedule is reenabled.",
+    }
+
+
+@dataclass(frozen=True)
+class ScheduleStatus(ModelBase):
+    """Current status of a schedule."""
+
+    __doc_py_example__ = """\
+import anyscale
+from anyscale.schedule.models import ScheduleStatus
+status: ScheduleStatus = anyscale.schedule.status(name="my-schedule")
+"""
+
+    __doc_cli_example__ = """\
+$ anyscale schedule status -n my-schedule
+id: cronjob_dfhqufws6s3issltpjgrdzcgyc
+name: my-schedule
+state: ENABLED
+"""
+
+    config: ScheduleConfig = field(
+        metadata={"docstring": "Configuration of the schedule."}
+    )
+
+    def _validate_config(self, config: ScheduleConfig):
+        if not isinstance(config, ScheduleConfig):
+            raise TypeError("'config' must be a ScheduleConfig.")
+
+    id: str = field(
+        metadata={
+            "docstring": "Unique ID of the schedule (generated when the schedule is first submitted)."
+        }
+    )
+
+    def _validate_id(self, id: str):  # noqa: A002
+        if not isinstance(id, str):
+            raise TypeError("'id' must be a string.")
+
+    name: str = field(metadata={"docstring": "Name of the schedule."},)
+
+    def _validate_name(self, name: str):
+        if not isinstance(name, str):
+            raise TypeError("'name' must be a string.")
+
+    state: Union[str, ScheduleState] = field(
+        metadata={"docstring": "Current state of the schedule."}
+    )
+
+    def _validate_state(self, state: Union[str, ScheduleState]) -> ScheduleState:
+        return ScheduleState.validate(state)

anyscale/scripts.py

@@ -0,0 +1,164 @@
+import json
+import logging
+import os
+from typing import Any
+
+import click
+
+from anyscale.cli_logger import BlockLogger
+from anyscale.commands.aggregated_instance_usage_commands import (
+    aggregated_instance_usage_cli,
+)
+from anyscale.commands.anyscale_api.api_commands import anyscale_api
+from anyscale.commands.auth_commands import auth_cli
+from anyscale.commands.cloud_commands import cloud_cli
+from anyscale.commands.cluster_commands import cluster_cli
+from anyscale.commands.cluster_env_commands import cluster_env_cli
+from anyscale.commands.compute_config_commands import compute_config_cli
+from anyscale.commands.config_commands import config_cli
+from anyscale.commands.exec_commands import anyscale_exec
+from anyscale.commands.experimental_integrations_commands import (
+    experimental_integrations_cli,
+)
+from anyscale.commands.image_commands import image_cli
+from anyscale.commands.job_commands import job_cli
+from anyscale.commands.list_commands import list_cli
+from anyscale.commands.llm.group import llm_cli
+from anyscale.commands.login_commands import anyscale_login, anyscale_logout
+from anyscale.commands.logs_commands import log_cli
+from anyscale.commands.machine_commands import machine_cli
+from anyscale.commands.machine_pool_commands import machine_pool_cli
+from anyscale.commands.migrate_commands import migrate_cli
+from anyscale.commands.project_commands import anyscale_init, project_cli
+from anyscale.commands.resource_quota_commands import resource_quota_cli
+from anyscale.commands.schedule_commands import schedule_cli
+from anyscale.commands.service_account_commands import service_account_cli
+from anyscale.commands.service_commands import service_cli
+from anyscale.commands.session_commands_hidden import session_cli
+from anyscale.commands.workspace_commands import workspace_cli
+from anyscale.commands.workspace_commands_v2 import workspace_cli as workspace_cli_v2
+import anyscale.conf
+from anyscale.utils.cli_version_check_util import log_warning_if_version_needs_upgrade
+
+
+logger = logging.getLogger(__name__)
+logging.getLogger("botocore").setLevel(logging.CRITICAL)
+
+log = BlockLogger()  # CLI Logger
+
+if anyscale.conf.AWS_PROFILE is not None:
+    logger.info("Using AWS profile %s", anyscale.conf.AWS_PROFILE)
+    os.environ["AWS_PROFILE"] = anyscale.conf.AWS_PROFILE
+
+
+class AliasedGroup(click.Group):
+    # This is from https://stackoverflow.com/questions/46641928/python-click-multiple-command-names
+    def get_command(self, ctx: Any, cmd_name: str) -> Any:
+        if cmd_name in ALIASES:
+            cmd_name = ALIASES[cmd_name].name
+        return super().get_command(ctx, cmd_name)
+
+
+@click.group(
+    "anyscale",
+    invoke_without_command=True,
+    no_args_is_help=True,
+    cls=AliasedGroup,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.option(
+    "--version",
+    "-v",
+    "version_flag",
+    is_flag=True,
+    default=False,
+    help="Current anyscale version.",
+)
+@click.option(
+    "--json",
+    "show_json",
+    is_flag=True,
+    default=False,
+    help="Return output as json, for use with --version.",
+)
+@click.pass_context
+def cli(ctx: Any, version_flag: bool, show_json: bool) -> None:
+    if version_flag:
+        ctx.invoke(version_cli, show_json=show_json)
+    log_warning_if_version_needs_upgrade()
+
+
+@click.command(name="version", help="Display version of the anyscale CLI.")
+@click.option(
+    "--json", "show_json", is_flag=True, default=False, help="Return output as json."
+)
+def version_cli(show_json: bool) -> None:
+    if show_json:
+        print(json.dumps({"version": anyscale.__version__}))
+    else:
+        print(anyscale.__version__)
+
+
+@cli.command(
+    name="help", help="Display help documentation for anyscale CLI.", hidden=True
+)
+@click.pass_context
+def anyscale_help(ctx: Any) -> None:
+    print(ctx.parent.get_help())
+
+
+cli.add_command(session_cli)
+cli.add_command(cloud_cli)
+cli.add_command(config_cli)
+cli.add_command(migrate_cli)
+cli.add_command(project_cli)
+cli.add_command(version_cli)
+cli.add_command(list_cli)
+cli.add_command(cluster_env_cli)
+cli.add_command(job_cli)
+cli.add_command(schedule_cli)
+cli.add_command(service_cli)
+cli.add_command(cluster_cli)
+cli.add_command(workspace_cli)
+cli.add_command(workspace_cli_v2)
+cli.add_command(experimental_integrations_cli)
+cli.add_command(auth_cli)
+cli.add_command(llm_cli)
+
+cli.add_command(anyscale_init)
+cli.add_command(anyscale_exec)
+cli.add_command(anyscale_help)
+cli.add_command(compute_config_cli)
+cli.add_command(image_cli)
+
+# Commands to interact with the Anyscale API
+cli.add_command(anyscale_api)
+
+cli.add_command(log_cli)
+cli.add_command(anyscale_login)
+cli.add_command(anyscale_logout)
+cli.add_command(machine_cli)
+cli.add_command(machine_pool_cli)
+cli.add_command(service_account_cli)
+cli.add_command(resource_quota_cli)
+cli.add_command(aggregated_instance_usage_cli)
+
+ALIASES = {
+    "h": anyscale_help,
+    "schedules": schedule_cli,
+    "jobs": job_cli,
+    "services": service_cli,
+    "cluster-compute": compute_config_cli,
+    "images": image_cli,
+    "sa": service_account_cli,
+}
+
+
+def main() -> Any:
+    return cli()
+
+
+if __name__ == "__main__":
+    logger.addHandler(logging.StreamHandler())
+    logger.setLevel(os.environ.get("ANYSCALE_LOGLEVEL", "WARN"))
+    main()