sdkagent

ray API reference

400 public APIs from ray (ray-project/ray) — 104 classes, 154 functions, 142 methods. Signatures extracted by static analysis of the actual source.

Repository: ray-project/ray

KindCount
Classes104
Functions154
Methods142

API list

funcci.lint.pytest_checker.check_file(file_contents:str) -> bool
Check file for the snippet
funcci.lint.pytest_checker.treat_path(path:str) -> Path
Treat bazel paths to filesystem paths
classci.ray_ci.automation.copy_wanda_image.CopyWandaImageError
Error raised when copying Wanda-cached images fails.
classci.ray_ci.automation.crane_lib.CraneError
Exception raised when a crane operation fails.
funcci.ray_ci.automation.crane_lib.call_crane_copy(source:str, destination:str) -> None
Copy a container image from source to destination.
funcci.ray_ci.automation.crane_lib.call_crane_export(tag:str, output_dir:str) -> None
Export a container image to a tar file and extract it.
funcci.ray_ci.automation.crane_lib.call_crane_manifest(tag:str) -> str
Fetch the manifest for a container image.
classci.ray_ci.automation.docker_tags_lib.AuthTokenException
Exception for failing to retrieve auth token.
classci.ray_ci.automation.docker_tags_lib.DockerHubRateLimitException
Exception for Docker Hub rate limit exceeded.
classci.ray_ci.automation.docker_tags_lib.RetrieveImageConfigException
Exception for failing to retrieve image config.
funcci.ray_ci.automation.docker_tags_lib.backup_release_tags(namespace:str, repository:str, aws_ecr_repo:str, docker_username:str, docker_password:str, release_versions:Optional[List[str]]=None) -> None
Backup release tags to AWS ECR.
funcci.ray_ci.automation.docker_tags_lib.copy_tag_to_aws_ecr(tag:str, aws_ecr_repo:str) -> bool
Copy tag from Docker Hub to AWS ECR.
funcci.ray_ci.automation.docker_tags_lib.delete_tag(tag:str, docker_hub_token:str) -> bool
Delete tag from Docker Hub repo.
funcci.ray_ci.automation.docker_tags_lib.get_ray_commit(image_name:str) -> str
Get the commit hash of Ray in the image.
funcci.ray_ci.automation.docker_tags_lib.list_image_tags(prefix:str, ray_type:str, python_versions:List[str], platforms:List[str], architectures:List[str]) -> List[str]
List all tags for a Docker build version.
funcci.ray_ci.automation.docker_tags_lib.query_tags_from_docker_with_oci(namespace:str, repository:str) -> List[str]
Query all repo tags from Docker using OCI API.
funcci.ray_ci.automation.filter_tests.main(prefix:str, state_filter:str) -> None
Filter flaky tests.
classci.ray_ci.automation.image_tags_lib.ImageTagsError
Error raised when image tag operations fail.
funcci.ray_ci.automation.image_tags_lib.format_platform_tag(platform:str) -> str
Format platform as -cpu, -tpu, or shortened CUDA version.
funcci.ray_ci.automation.image_tags_lib.format_python_tag(python_version:str) -> str
Format python version as -py310 (no dots, with hyphen prefix).
funcci.ray_ci.automation.image_tags_lib.get_variation_suffix(image_type:str) -> str
Get variation suffix for -extra image types.
funcci.ray_ci.automation.image_tags_lib.image_exists(tag:str) -> bool
Check if a container image manifest exists using crane.
classci.ray_ci.automation.push_ray_image.PushRayImageError
Error raised when pushing ray images fails.
funcci.ray_ci.automation.push_ray_image.compact_cuda_suffix(platform:str) -> str
Convert a CUDA platform string to compact suffix (e.g.
funcci.ray_ci.automation.ray_wheels_lib.add_build_tag_to_wheel(wheel_path:str, build_tag:str) -> None
Add build tag to the wheel.
funcci.ray_ci.automation.ray_wheels_lib.add_build_tag_to_wheels(directory_path:str, build_tag:str) -> None
Add build tag to all wheels in the given directory.
funcci.ray_ci.automation.ray_wheels_lib.download_wheel_from_s3(key:str, directory_path:str) -> None
Download a Ray wheel from S3 to the given directory.
classci.ray_ci.bazel_sharding.BazelRule
Dataclass representing a bazel py_test rule (BUILD entry).
methodci.ray_ci.bazel_sharding.BazelRule.from_xml_element(element:ET.Element) -> 'BazelRule'
Create a BazelRule from an XML element.
funcci.ray_ci.bazel_sharding.generate_regex_from_tags(tags:Iterable[str]) -> str
Turn tag filters into a regex used in bazel query.
funcci.ray_ci.bazel_sharding.run_bazel_query(query:str, debug:bool) -> ET.Element
Runs bazel query with XML output format.
funcci.ray_ci.bazel_sharding.split_tag_filters(tag_str:str) -> Tuple[Set[str], Set[str]]
Split tag_filters string into include & exclude tags.
funcci.ray_ci.builder.build_anyscale(image_type:str, python_version:str, build_type:str, platform:List[str], architecture:str, canonical_tag:str, upload:bool) -> None
Build an anyscale container artifact.
funcci.ray_ci.builder.build_docker(image_type:str, python_version:str, build_type:str, platform:List[str], architecture:str, canonical_tag:str, upload:bool) -> None
Build a container artifact.
funcci.ray_ci.builder.build_wheel(python_version:str, build_type:str, architecture:str, operating_system:str, upload:bool) -> None
Build a wheel artifact.
funcci.ray_ci.builder.main(artifact_type:str, image_type:str, build_type:str, python_version:str, platform:List[str], architecture:str, operating_system:str, canonical_tag:str, upload:bool) -> None
Build a wheel or jar artifact
classci.ray_ci.container.Container
A wrapper for running commands in ray ci docker container
methodci.ray_ci.container.Container.get_artifact_mount() -> Tuple[str, str]
Get artifact mount path on host and container
methodci.ray_ci.container.Container.run_script(script:List[str]) -> None
Run a script in container
methodci.ray_ci.container.Container.run_script_with_output(script:List[str]) -> str
Run a script in container and returns output
funcci.ray_ci.container.get_docker_image(docker_tag:str, build_id:Optional[str]=None) -> str
Get rayci image for a particular tag.
classci.ray_ci.docker_container.DockerContainer
Container for building and publishing ray docker images
classci.ray_ci.ray_docker_container.RayDockerContainer
Container for building and publishing ray docker images
methodci.ray_ci.ray_docker_container.RayDockerContainer.run(base:Optional[str]=None) -> None
Build and publish ray docker images
classci.ray_ci.ray_image.RayImage
Immutable identity of a Ray Docker image variant.
methodci.ray_ci.ray_image.RayImage.repo() -> str
Docker Hub repository name (e.g.
methodci.ray_ci.ray_image.RayImage.wanda_image_name() -> str
Wanda output image name (without registry prefix).
classci.ray_ci.ray_image.RayImageError
Raised when a RayImage field combination is invalid.
classci.ray_ci.tester_container.TesterContainer
A wrapper for running tests in ray ci docker container
methodci.ray_ci.tester_container.TesterContainer.run_tests(team:str, test_targets:List[str], test_arg:Optional[str]=None, is_bisect_run:bool=False, run_flaky_tests:bool=False, cache_test_results:bool=False) -> bool
Run tests parallelly in docker.
funcci.ray_ci.utils.add_handlers(logger:logging.Logger)
Add handlers to logger
funcci.ray_ci.utils.chunk_into_n(list:List[str], n:int) -> List[List[str]]
Chunk a list into n chunks
funcci.ray_ci.utils.ci_init() -> None
Initialize global config
funcci.ray_ci.utils.docker_pull(image:str) -> None
Pull docker image
funcci.ray_ci.utils.ecr_docker_login(docker_ecr:str) -> None
Login to ECR with AWS credentials
funcci.ray_ci.utils.get_flaky_test_names(prefix:str) -> List[str]
Query all flaky tests with specified prefix.
funcci.raydepsets.cli.cli()
Manage Python dependency sets.
funcpython.ray._common.network_utils.find_free_port(family:socket.AddressFamily=socket.AF_INET) -> int
Find a free port on the local machine.
methodpython.ray._common.ray_option_utils.Option.validate(keyword:str, value:Any)
Validate the option.
funcpython.ray._common.ray_option_utils.update_options(original_options:Dict[str, Any], new_options:Dict[str, Any]) -> Dict[str, Any]
Update original options with new options and return.
funcpython.ray._common.ray_option_utils.validate_actor_options(options:Dict[str, Any], in_options:bool)
Options check for Ray actors.
funcpython.ray._common.retry.call_with_retry(f:Callable[P, R], description:str, match:Optional[Sequence[str]]=None, max_attempts:int=10, max_backoff_s:int=32, *args:P.args, **kwargs:P.kwargs) -> R
Retry a function with exponential backoff.
funcpython.ray._common.retry.format_exception(exc:BaseException, include_cause:bool=False) -> str
Format ``exc`` as ``"ClassName: message"`` for substring/regex matching.
funcpython.ray._common.signature.extract_signature(func:Any, ignore_first:bool=False) -> List[Parameter]
Extract the function signature from the function.
funcpython.ray._common.signature.get_signature(func:Any) -> inspect.Signature
Get signature parameters.
funcpython.ray._common.signature.validate_args(signature_parameters:List[Parameter], args:Tuple[Any, ...], kwargs:Dict[str, Any]) -> None
Validates the arguments against the signature.
funcpython.ray._common.tls_utils.generate_self_signed_tls_certs() -> Tuple[str, str]
Create self-signed key/cert pair for testing.
classpython.ray._common.usage.usage_lib.UsageReportClient
The client implementation for usage report.
methodpython.ray._common.usage.usage_lib.UsageReportClient.report_usage_data(url:str, data:UsageStatsToReport) -> None
Report the usage data to the usage server.
methodpython.ray._common.usage.usage_lib.UsageReportClient.write_usage_data(data:UsageStatsToWrite, dir_path:str) -> None
Write the usage data to the directory.
classpython.ray._common.usage.usage_lib.UsageStatsToReport
Usage stats to report
funcpython.ray._common.usage.usage_lib.generate_report_data(cluster_config_to_report:ClusterConfigToReport, total_success:int, total_failed:int, seq_number:int, gcs_address:str, cluster_id:str) -> UsageStatsToReport
Generate the report data.
funcpython.ray._common.usage.usage_lib.generate_write_data(usage_stats:UsageStatsToReport, error:str) -> UsageStatsToWrite
Generate the report data.
funcpython.ray._common.usage.usage_lib.get_cluster_metadata(gcs_client:GcsClient) -> dict
Get the cluster metadata from GCS.
funcpython.ray._common.usage.usage_lib.get_cluster_status_to_report(gcs_client:GcsClient) -> ClusterStatusToReport
Get the current status of this cluster.
funcpython.ray._common.usage.usage_lib.get_extra_usage_tags_to_report(gcs_client:GcsClient) -> Dict[str, str]
Get the extra usage tags from env var and gcs kv store.
funcpython.ray._common.usage.usage_lib.is_ray_init_cluster(gcs_client:ray._raylet.GcsClient) -> bool
Return whether the cluster is started by ray.init()
funcpython.ray._common.usage.usage_lib.put_cluster_metadata(gcs_client:GcsClient, *ray_init_cluster:bool) -> dict
Generate the cluster metadata and store it to GCS.
funcpython.ray._common.usage.usage_lib.record_extra_usage_tag(key:TagKey, value:str, gcs_client:Optional[GcsClient]=None)
Record extra kv usage tag.
funcpython.ray._common.usage.usage_lib.record_hardware_usage(hardware_usage:str)
Record hardware usage (e.g.
funcpython.ray._common.usage.usage_lib.record_library_usage(library_usage:str)
Record library usage (e.g.
funcpython.ray._common.utils.decode(byte_str:str, allow_none:bool=False, encode_type:str='utf-8')
Make this unicode in Python 3, otherwise leave it as bytes.
funcpython.ray._common.utils.import_attr(full_path:str, *reload_module:bool=False) -> Any
Given a full import path to a module attr, return the imported attr.
funcpython.ray._common.utils.resolve_user_ray_temp_dir(gcs_client:GcsClient, node_id:str)
Get the ray temp directory.
funcpython.ray._common.utils.resources_from_ray_options(options_dict:Dict[str, Any]) -> Dict[str, Any]
Determine a task's resource requirements.
funcpython.ray._common.utils.run_background_task(coroutine:Coroutine) -> asyncio.Task
Schedule a task reliably to the event loop.
classpython.ray._private.accelerators.amd_gpu.AMDGPUAcceleratorManager
AMD GPU accelerators.
classpython.ray._private.accelerators.apple_gpu.AppleGPUAcceleratorManager
Apple Silicon GPU (MPS) accelerator manager.
methodpython.ray._private.accelerators.apple_gpu.AppleGPUAcceleratorManager.set_current_process_visible_accelerator_ids(ids:List[str]) -> None
No-op for Apple Silicon.
classpython.ray._private.accelerators.furiosa.FuriosaAcceleratorManager
FuriosaAI NPU accelerators.
funcpython.ray._private.accelerators.get_all_accelerator_managers() -> Set[AcceleratorManager]
Get all accelerator managers supported by Ray.
funcpython.ray._private.accelerators.get_all_accelerator_resource_names() -> Set[str]
Get all resource names for accelerators.
classpython.ray._private.accelerators.hpu.HPUAcceleratorManager
Intel Habana(HPU) accelerators.
methodpython.ray._private.accelerators.hpu.HPUAcceleratorManager.is_initialized() -> bool
Attempt to check if HPU backend is initialized.
classpython.ray._private.accelerators.intel_gpu.IntelGPUAcceleratorManager
Intel GPU accelerators.
methodpython.ray._private.accelerators.intel_gpu.IntelGPUAcceleratorManager.get_current_node_accelerator_type() -> Optional[str]
Get the name of first Intel GPU.
classpython.ray._private.accelerators.metax_gpu.MetaxGPUAcceleratorManager
Metax GPU accelerators.
classpython.ray._private.accelerators.neuron.NeuronAcceleratorManager
AWS Inferentia and Trainium accelerators.
classpython.ray._private.accelerators.npu.NPUAcceleratorManager
Ascend NPU accelerators.
classpython.ray._private.accelerators.nvidia_gpu.NvidiaGPUAcceleratorManager
NVIDIA GPU accelerators.
classpython.ray._private.accelerators.rbln.RBLNAcceleratorManager
Rebellions RBLN accelerators.
classpython.ray._private.accelerators.tpu.TPUAcceleratorManager
Google TPU accelerators.
methodpython.ray._private.accelerators.tpu.TPUAcceleratorManager.is_valid_tpu_accelerator_topology(tpu_accelerator_version:str, tpu_topology:str) -> bool
Check whether the tpu topology is valid.
funcpython.ray._private.accelerators.tpu.get_num_chips_from_topology(topology:str) -> int
Calculates the total number of chips in a TPU topology.
funcpython.ray._private.accelerators.tpu.infer_tpu_pod_type_from_topology(topology:str, accelerator_type:str) -> Optional[str]
Infer the TPU pod type (e.g.
classpython.ray._private.accelerators.ttnpu.TTNPUAcceleratorManager
Tenstorrent NPU accelerators.
funcpython.ray._private.async_compat.get_new_event_loop()
Construct a new event loop.
funcpython.ray._private.async_compat.has_async_methods(cls:object) -> bool
Return True if the class has any async methods.
funcpython.ray._private.async_utils.enable_monitor_loop_lag(callback:Callable[[float], None], interval_s:float=0.25, loop:Optional[asyncio.AbstractEventLoop]=None) -> None
Start logging event loop lags to the callback.
funcpython.ray._private.authentication.authentication_utils.is_token_auth_enabled() -> bool
Check if token authentication is enabled.
funcpython.ray._private.authentication_test_utils.set_auth_mode(mode:str) -> None
Set the authentication mode environment variable.
funcpython.ray._private.authentication_test_utils.set_env_auth_token(token:str) -> None
Configure the authentication token via environment variable.
funcpython.ray._private.collections_utils.split(items:List[Any], chunk_size:int)
Splits provided list into chunks of given size
funcpython.ray._private.dict.flatten_dict(dt:Dict, delimiter:str='/', prevent_delimiter:bool=False, flatten_list:bool=False)
Flatten dict.
funcpython.ray._private.dict.merge_dicts(d1:dict, d2:dict) -> dict
Args: d1: Dict 1.
funcpython.ray._private.dict.unflatten_dict(dt:Dict[str, T], delimiter:str='/') -> Dict[str, T]
Unflatten dict.
funcpython.ray._private.dict.unflatten_list_dict(dt:Dict[str, T], delimiter:str='/') -> Dict[str, T]
Unflatten nested dict and list.
funcpython.ray._private.event.event_logger.filter_event_by_level(event:Event, filter_event_level:str) -> bool
Filter an event based on event level.
funcpython.ray._private.event.event_logger.parse_event(event_str:str) -> Optional[Event]
Parse an event from a string.
classpython.ray._private.external_storage.ExternalStorage
The base class for external storage.
methodpython.ray._private.external_storage.ExternalStorage.restore_spilled_objects(object_refs:List[ObjectRef], url_with_offset_list:List[str]) -> int
Restore objects from the external storage.
methodpython.ray._private.external_storage.ExternalStorage.spill_objects(object_refs:List[ObjectRef], owner_addresses:List[str]) -> List[str]
Spill objects to the external storage.
classpython.ray._private.external_storage.FileSystemStorage
The class for filesystem-like external storage.
classpython.ray._private.external_storage.SlowFileStorage
This class is for testing slow object spilling.
classpython.ray._private.external_storage.UnstableFileStorage
This class is for testing with writing failure.
funcpython.ray._private.external_storage.create_url_with_offset(*url:str, *offset:int, *size:int) -> str
Methods to create a URL with offset.
funcpython.ray._private.external_storage.parse_url_with_offset(url_with_offset:str) -> Tuple[str, int, int]
Parse url_with_offset to retrieve information.
funcpython.ray._private.external_storage.spill_objects(object_refs:List[ObjectRef], owner_addresses:List[str]) -> List[str]
Spill objects to the external storage.
funcpython.ray._private.gcs_utils.create_gcs_channel(address:str, aio:bool=False)
Returns a GRPC channel to GCS.
funcpython.ray._private.inspect_util.is_function_or_method(obj:object) -> bool
Check if an object is a function or method.
classpython.ray._private.log.PlainRayHandler
A plain log handler.
methodpython.ray._private.log.PlainRayHandler.emit(record:logging.LogRecord)
Emit the log message.
funcpython.ray._private.log.format_returncode(rc:Optional[int]) -> str
Return a consistent string for process return code.
classpython.ray._private.log_monitor.LogMonitor
A monitor process for monitoring Ray log files.
methodpython.ray._private.log_monitor.LogMonitor.get_is_autoscaler_v2(gcs_address:Optional[str]) -> bool
Check if autoscaler v2 is enabled.
methodpython.ray._private.log_monitor.LogMonitor.run()
Run the log monitor.
methodpython.ray._private.log_monitor.LogMonitor.should_update_filenames(last_file_updated_time:float) -> bool
Return true if filenames should be updated.
classpython.ray._private.memory_monitor.MemoryMonitor
Helper class for raising errors on low memory.
classpython.ray._private.metrics_agent.Gauge
Gauge representation of opencensus view.
classpython.ray._private.metrics_agent.PrometheusServiceDiscoveryWriter
A class to support Prometheus service discovery.
classpython.ray._private.node.Node
An encapsulation of the Ray processes on a single node.
methodpython.ray._private.node.Node.address()
Get the address for bootstrapping, e.g.
methodpython.ray._private.node.Node.address_info()
Get a dictionary of addresses.
methodpython.ray._private.node.Node.dead_processes()
Return a list of the dead processes.
methodpython.ray._private.node.Node.gcs_address()
Get the gcs address.
methodpython.ray._private.node.Node.get_runtime_env_dir_path()
Get the path of the runtime env.
methodpython.ray._private.node.Node.get_session_dir_path()
Get the path of the session directory.
methodpython.ray._private.node.Node.kill_all_processes(check_alive:bool=True, allow_graceful:bool=False, wait:bool=False)
Kill all of the processes.
methodpython.ray._private.node.Node.kill_dashboard(check_alive:bool=True)
Kill the dashboard.
methodpython.ray._private.node.Node.kill_gcs_server(check_alive:bool=True)
Kill the gcs server.
methodpython.ray._private.node.Node.kill_log_monitor(check_alive:bool=True)
Kill the log monitor.
methodpython.ray._private.node.Node.kill_monitor(check_alive:bool=True)
Kill the monitor.
methodpython.ray._private.node.Node.kill_raylet(check_alive:bool=True)
Kill the raylet.
methodpython.ray._private.node.Node.kill_reaper(check_alive:bool=True)
Kill the reaper process.
methodpython.ray._private.node.Node.kill_redis(check_alive:bool=True)
Kill the Redis servers.
methodpython.ray._private.node.Node.live_processes()
Return a list of the live processes.
methodpython.ray._private.node.Node.metrics_agent_port()
Get the metrics agent gRPC port
methodpython.ray._private.node.Node.metrics_export_port()
Get the port that exposes metrics
methodpython.ray._private.node.Node.node_id()
Get the node ID.
methodpython.ray._private.node.Node.node_ip_address()
Get the IP address of this node.
methodpython.ray._private.node.Node.node_labels()
Get the node labels.
methodpython.ray._private.node.Node.node_manager_port()
Get the node manager's port.
methodpython.ray._private.node.Node.raylet_socket_name()
Get the node's raylet socket name.
methodpython.ray._private.node.Node.redis_address()
Get the cluster Redis address.
methodpython.ray._private.node.Node.redis_password()
Get the cluster Redis password.
methodpython.ray._private.node.Node.redis_username()
Get the cluster Redis username.
methodpython.ray._private.node.Node.session_name()
Get the current Ray session name.
methodpython.ray._private.node.Node.start_api_server(*include_dashboard:Optional[bool], *raise_on_failure:bool)
Start the dashboard.
methodpython.ray._private.node.Node.start_gcs_server()
Start the gcs server.
methodpython.ray._private.node.Node.start_head_processes()
Start head processes on the node.
methodpython.ray._private.node.Node.start_log_monitor()
Start the log monitor.
methodpython.ray._private.node.Node.start_monitor()
Start the monitor.
methodpython.ray._private.node.Node.start_raylet(plasma_directory:str, fallback_directory:str, object_store_memory:int, use_valgrind:bool=False, use_profiler:bool=False)
Start the raylet.
methodpython.ray._private.node.Node.start_reaper_process()
Start the reaper process.
methodpython.ray._private.node.Node.unique_id()
Get a unique identifier for this node.
methodpython.ray._private.node.Node.webui_url()
Get the cluster's web UI url.
classpython.ray._private.parameter.RayParams
A class used to store the parameters used by Ray.
methodpython.ray._private.parameter.RayParams.update(**kwargs)
Update the settings according to the keyword arguments.
funcpython.ray._private.path_utils.is_path(path_or_uri:str) -> bool
Returns True if uri_or_path is a path and False otherwise.
funcpython.ray._private.profiling.chrome_tracing_dump(tasks:List[dict]) -> str
Generate a chrome/perfetto tracing dump using task events.
classpython.ray._private.prometheus_exporter.Collector
Collector represents the Prometheus Collector object
methodpython.ray._private.prometheus_exporter.Collector.options()
Options to be used to configure the exporter
methodpython.ray._private.prometheus_exporter.Collector.registered_views()
Map with all registered views
classpython.ray._private.prometheus_exporter.Options
Options contains options for configuring the exporter.
methodpython.ray._private.prometheus_exporter.Options.namespace()
Prefix to be used with view name
methodpython.ray._private.prometheus_exporter.Options.port()
Port number to listen
classpython.ray._private.prometheus_exporter.PrometheusStatsExporter
Exporter exports stats to Prometheus.
funcpython.ray._private.prometheus_exporter.get_view_name(namespace, view)
create the name for the view
funcpython.ray._private.ray_logging.setup_logger(logging_level:int, logging_format:str)
Setup default logging for ray.
classpython.ray._private.runtime_env.agent.runtime_env_agent.ReferenceTable
The URI reference table which is used for GC.
classpython.ray._private.runtime_env.agent.runtime_env_agent.RuntimeEnvAgent
An RPC server to create and delete runtime envs.
funcpython.ray._private.runtime_env.conda_utils.exec_cmd(cmd:List[str], throw_on_error:bool=True, logger:Optional[logging.Logger]=None) -> Union[int, Tuple[int, str, str]]
Runs a command as a child process.
funcpython.ray._private.runtime_env.conda_utils.get_conda_env_list() -> list
Get conda env list in full paths.
funcpython.ray._private.runtime_env.conda_utils.get_conda_info_json() -> dict
Get `conda info --json` output.
classpython.ray._private.runtime_env.context.RuntimeEnvContext
A context used to describe the created runtime env.
classpython.ray._private.runtime_env.image_uri.ContainerPlugin
Starts worker in container.
classpython.ray._private.runtime_env.image_uri.ImageURIPlugin
Starts worker in a container of a custom image.
funcpython.ray._private.runtime_env.packaging.delete_package(pkg_uri:str, base_directory:str) -> Tuple[bool, int]
Deletes a specific URI from the local filesystem.
funcpython.ray._private.runtime_env.packaging.get_local_dir_from_uri(uri:str, base_directory:str) -> Path
Return the local directory corresponding to this URI.
funcpython.ray._private.runtime_env.packaging.get_uri_for_file(file:str) -> str
Get a content-addressable URI from a file's content.
funcpython.ray._private.runtime_env.packaging.get_uri_for_package(package:Path) -> str
Get a content-addressable URI from a package's contents.
funcpython.ray._private.runtime_env.packaging.package_exists(pkg_uri:str) -> bool
Check whether the package with given URI exists or not.
funcpython.ray._private.runtime_env.packaging.parse_path(pkg_path:str) -> None
Parse the path to check it is well-formed and exists.
funcpython.ray._private.runtime_env.packaging.upload_package_to_gcs(pkg_uri:str, pkg_bytes:bytes) -> None
Upload a local package to GCS.
classpython.ray._private.runtime_env.plugin.RuntimeEnvPlugin
Abstract base class for runtime environment plugins.
methodpython.ray._private.runtime_env.plugin.RuntimeEnvPlugin.delete_uri(uri:str, logger:logging.Logger) -> float
Delete the runtime environment given uri.
methodpython.ray._private.runtime_env.plugin.RuntimeEnvPlugin.validate(runtime_env_dict:dict) -> None
Validate user entry for this plugin.
funcpython.ray._private.runtime_env.setup_hook.load_and_execute_setup_hook(worker_process_setup_hook_key:str) -> Optional[str]
Load the setup hook from a given key and execute.
classpython.ray._private.runtime_env.uri_cache.URICache
Caches URIs up to a specified total size limit.
methodpython.ray._private.runtime_env.uri_cache.URICache.add(uri:str, size_bytes:int, logger:logging.Logger=default_logger)
Add a URI to the cache and mark it as in use.
methodpython.ray._private.runtime_env.uri_cache.URICache.mark_used(uri:str, logger:logging.Logger=default_logger)
Mark a URI as in use.
funcpython.ray._private.runtime_env.validation.parse_and_validate_conda(conda:Union[str, dict]) -> Union[str, dict]
Parses and validates a user-provided 'conda' option.
funcpython.ray._private.runtime_env.validation.parse_and_validate_excludes(excludes:List[str]) -> List[str]
Parses and validates a user-provided 'excludes' option.
funcpython.ray._private.runtime_env.validation.parse_and_validate_pip(pip:Union[str, List[str], Dict]) -> Optional[Dict]
Parses and validates a user-provided 'pip' option.
funcpython.ray._private.runtime_env.validation.parse_and_validate_py_modules(py_modules:List[str]) -> List[str]
Parses and validates a 'py_modules' option.
funcpython.ray._private.runtime_env.validation.parse_and_validate_uv(uv:Union[str, List[str], Dict]) -> Optional[Dict]
Parses and validates a user-provided 'uv' option.
funcpython.ray._private.runtime_env.validation.parse_and_validate_working_dir(working_dir:str) -> str
Parses and validates a 'working_dir' option.
funcpython.ray._private.runtime_env.validation.validate_path(path:str) -> None
Parse the path to ensure it is well-formed and exists.
funcpython.ray._private.runtime_env.validation.validate_py_modules_uris(py_modules_uris:List[str]) -> List[str]
Parses and validates a 'py_modules' option.
funcpython.ray._private.runtime_env.validation.validate_working_dir_uri(working_dir_uri:str) -> str
Parses and validates a 'working_dir' option.
funcpython.ray._private.runtime_env.virtualenv_utils.get_virtualenv_activate_command(target_dir:str) -> List[str]
Get the command to activate virtual environment.
funcpython.ray._private.runtime_env.virtualenv_utils.get_virtualenv_path(target_dir:str) -> str
Get virtual environment path.
classpython.ray._private.serialization.SerializationContext
Initialize the serialization library.
methodpython.ray._private.serialization.SerializationContext.serialize(value:Any) -> Union[RawSerializedObject, MessagePackSerializedObject]
Serialize an object.
methodpython.ray._private.serialization.SerializationContext.store_rdt_objects(obj_id:str, tensors:List[Any], tensor_transport:str) -> bytes
Store RDT objects in the RDT store.
funcpython.ray._private.services.canonicalize_bootstrap_address(addr:str, temp_dir:Optional[str]=None) -> Optional[str]
Canonicalizes Ray cluster bootstrap address to host:port.
funcpython.ray._private.services.canonicalize_bootstrap_address_or_die(addr:str, temp_dir:Optional[str]=None) -> str
Canonicalizes Ray cluster bootstrap address to host:port.
funcpython.ray._private.services.create_redis_client(redis_address:str, password:Optional[str]=None, username:Optional[str]=None)
Create a Redis client.
funcpython.ray._private.services.get_node_with_retry(gcs_address:str, node_id:str, timeout_s:float=30, retry_interval_s:float=1) -> dict
Get node info from GCS with retry logic.
funcpython.ray._private.services.start_reaper(fate_share:Optional[bool]=None)
Start the reaper process.
classpython.ray._private.state.GlobalState
A class used to interface with the Ray control state.
methodpython.ray._private.state.GlobalState.add_worker(worker_id:bytes, worker_type:int, worker_info:Dict[str, str])
Add a worker to the cluster.
methodpython.ray._private.state.GlobalState.disconnect()
Disconnect global state from GCS.
methodpython.ray._private.state.GlobalState.get_actor_info(actor_id:ray.ActorID) -> Optional[str]
Get the actor info for a actor id.
methodpython.ray._private.state.GlobalState.get_node(node_id:str)
Get the node information for a node id.
methodpython.ray._private.state.GlobalState.get_worker_debugger_port(worker_id:bytes)
Get the debugger port of a worker.
methodpython.ray._private.state.GlobalState.job_table()
Fetch and parse the gcs job table.
methodpython.ray._private.state.GlobalState.next_job_id()
Get next job id from GCS.
methodpython.ray._private.state.GlobalState.update_worker_debugger_port(worker_id:bytes, debugger_port:int)
Update the debugger port of a worker.
funcpython.ray._private.state.get_worker_debugger_port(worker_id:bytes)
Get the debugger port of a worker.
funcpython.ray._private.state.next_job_id()
Get next job id from GCS.
funcpython.ray._private.state.update_worker_debugger_port(worker_id:bytes, debugger_port:int)
Update the debugger port of a worker.
funcpython.ray._private.state.workers()
Get a list of the workers in the cluster.
classpython.ray._private.telemetry.metric_types.MetricType
Types of metrics supported by the telemetry system.
classpython.ray._private.telemetry.open_telemetry_metric_recorder.OpenTelemetryMetricRecorder
A class to record OpenTelemetry metrics.
funcpython.ray._private.utils.check_oversized_function(pickled:bytes, name:str, obj_type:str, worker:'ray.Worker') -> None
Send a warning message if the pickled function is too large.
funcpython.ray._private.utils.ensure_str(s, encoding='utf-8', errors='strict')
Coerce *s* to `str`.
funcpython.ray._private.utils.get_num_cpus(override_docker_cpu_warning:bool=ENV_DISABLE_DOCKER_CPU_WARNING, truncate:bool=True) -> float
Get the number of CPUs available on this node.
funcpython.ray._private.utils.remove_ray_internal_flags_from_env(env:dict)
Remove Ray internal flags from `env`.
funcpython.ray._private.utils.resolve_object_store_memory(available_memory_bytes:int, object_store_memory:Optional[int]=None) -> int
Resolve the object store memory size.
funcpython.ray._private.utils.split_address(address:str) -> Tuple[str, str]
Splits address into a module string (scheme) and an inner_address.
funcpython.ray._private.utils.try_to_symlink(symlink_path:str, target_path:str)
Attempt to create a symlink.
classpython.ray._private.worker.BaseContext
Base class for RayContext and ClientContext
classpython.ray._private.worker.RayContext
Context manager for attached drivers.
classpython.ray._private.worker.Worker
A class used to define the control flow of a worker process.
methodpython.ray._private.worker.Worker.check_connected()
Check if the worker is connected.
methodpython.ray._private.worker.Worker.get_err_file_path() -> str
Get the err log file path
methodpython.ray._private.worker.Worker.get_out_file_path() -> str
Get the out log file path
methodpython.ray._private.worker.Worker.runtime_env()
Get the runtime env in json format
methodpython.ray._private.worker.Worker.set_file_rotation_enabled(rotation_enabled:bool) -> None
Set whether rotation is enabled for outfile and errfile.
methodpython.ray._private.worker.Worker.set_mode(mode:int)
Set the mode of the worker.
funcpython.ray._private.worker.cancel(ray_waitable:Union['ObjectRef[R]', 'ObjectRefGenerator[R]'], *force:bool=False, *recursive:bool=True) -> None
Cancels a task.
funcpython.ray._private.worker.color_for(data:Dict[str, str], line:str) -> str
The color for this log line.
funcpython.ray._private.worker.get_actor(name:str, namespace:Optional[str]=None) -> 'ray.actor.ActorHandle'
Get a handle to a named actor.
funcpython.ray._private.worker.is_initialized() -> bool
Check if ray.init has been called yet.
funcpython.ray._private.worker.kill(actor:'ray.actor.ActorHandle', *no_restart:bool=True)
Kill an actor forcefully.
funcpython.ray._private.worker.message_for(data:Dict[str, str], line:str) -> str
The printed message of this log line.
funcpython.ray._private.worker.prefix_for(data:Dict[str, str]) -> str
The PID prefix for this log line.
funcpython.ray._private.worker.put(value:R, *_owner:Optional['ray.actor.ActorHandle']=None, *_tensor_transport:Optional[str]=None) -> 'ray.ObjectRef[R]'
Store an object in the object store.
funcpython.ray._private.worker.restore_tqdm()
Undo hide_tqdm().
funcpython.ray._private.worker.time_string() -> str
Return the relative time from the start of this job.
classpython.ray.actor.ActorClass
An actor class.
methodpython.ray.actor.ActorClass.options(**actor_options:Any) -> 'ActorClass[T]'
Configures and overrides the actor instantiation parameters.
methodpython.ray.actor.ActorClass.remote(*args:Any, **kwargs:Any) -> ActorProxy[T]
Create an actor.
classpython.ray.actor.ActorHandle
A handle to an actor.
classpython.ray.actor.ActorMethod
A class used to invoke an actor method.
funcpython.ray.actor.exit_actor()
Intentionally exit the current actor.
classpython.ray.air._internal.device_manager.cpu.CPUTorchDeviceManager
CPU device manager
classpython.ray.air._internal.device_manager.hpu.HPUTorchDeviceManager
HPU device manager
classpython.ray.air._internal.device_manager.npu.NPUTorchDeviceManager
Ascend NPU device manager
classpython.ray.air._internal.device_manager.nvidia_gpu.CUDATorchDeviceManager
CUDA device manager
methodpython.ray.air._internal.device_manager.nvidia_gpu.CUDATorchDeviceManager.create_stream(device:torch.device) -> torch.cuda.Stream
Create a stream on cuda device
methodpython.ray.air._internal.device_manager.nvidia_gpu.CUDATorchDeviceManager.get_current_stream() -> torch.cuda.Stream
Get current stream for cuda device
classpython.ray.air._internal.device_manager.tpu.TPUTorchDeviceManager
TPU device manager using torch_tpu backend
classpython.ray.air._internal.filelock.TempFileLock
FileLock wrapper that uses temporary file locks.
funcpython.ray.air._internal.torch_utils.contains_tensor(obj:Any) -> bool
Check if the obj contains a torch tensor.
funcpython.ray.air._internal.usage.tag_air_entrypoint(entrypoint:AirEntrypoint) -> None
Records the entrypoint to an AIR training run.
classpython.ray.air._internal.util.RunnerThread
Supervisor thread that runs your script.
funcpython.ray.air._internal.util.skip_exceptions(exc:Optional[Exception]) -> Exception
Skip all contained `StartTracebacks` to reduce traceback output.
classpython.ray.air.config.RunConfig
Runtime configuration for training and tuning runs.
classpython.ray.air.config.ScalingConfig
Configuration for scaling training.
classpython.ray.air.execution._internal.actor_manager.RayActorManager
Management class for Ray actors and actor tasks.
methodpython.ray.air.execution._internal.actor_manager.RayActorManager.is_actor_started(tracked_actor:TrackedActor) -> bool
Returns True if the actor has been started.
methodpython.ray.air.execution._internal.actor_manager.RayActorManager.remove_actor(tracked_actor:TrackedActor, kill:bool=False, stop_future:Optional[ray.ObjectRef]=None) -> bool
Remove a tracked actor.
classpython.ray.air.execution._internal.barrier.Barrier
Barrier to collect results and process them in bulk.
methodpython.ray.air.execution._internal.barrier.Barrier.completed() -> bool
Returns True if the barrier is completed.
methodpython.ray.air.execution._internal.barrier.Barrier.get_results() -> List[Tuple[Any]]
Return list of received results.
methodpython.ray.air.execution._internal.barrier.Barrier.num_results() -> int
Number of received (successful) results.
methodpython.ray.air.execution._internal.barrier.Barrier.reset() -> None
Reset barrier, removing all received results.
classpython.ray.air.execution._internal.event_manager.RayEventManager
Event manager for Ray futures.
methodpython.ray.air.execution._internal.event_manager.RayEventManager.discard_future(future:ray.ObjectRef)
Remove future from tracking.
methodpython.ray.air.execution._internal.event_manager.RayEventManager.get_futures() -> Set[ray.ObjectRef]
Get futures tracked by the event manager.
methodpython.ray.air.execution._internal.event_manager.RayEventManager.resolve_future(future:ray.ObjectRef)
Resolve a single future.
classpython.ray.air.execution._internal.tracked_actor.TrackedActor
Actor tracked by an actor manager.
classpython.ray.air.execution._internal.tracked_actor_task.TrackedActorTask
Actor task tracked by a Ray event manager.
classpython.ray.air.execution.resources.fixed.FixedResourceManager
Fixed budget based resource manager.
classpython.ray.air.execution.resources.request.AcquiredResources
Base class for resources that have been acquired.
classpython.ray.air.execution.resources.request.ResourceRequest
Request for resources.
methodpython.ray.air.execution.resources.request.ResourceRequest.bundles() -> List[Dict[str, float]]
Returns a deep copy of resource bundles
methodpython.ray.air.execution.resources.request.ResourceRequest.head_cpus() -> float
Returns the number of cpus in the head bundle.
methodpython.ray.air.execution.resources.request.ResourceRequest.strategy() -> str
Returns the placement strategy
classpython.ray.air.execution.resources.resource_manager.ResourceManager
Resource manager interface.
methodpython.ray.air.execution.resources.resource_manager.ResourceManager.acquire_resources(resource_request:ResourceRequest) -> Optional[AcquiredResources]
Acquire resources.
methodpython.ray.air.execution.resources.resource_manager.ResourceManager.cancel_resource_request(resource_request:ResourceRequest)
Cancel resource request.
methodpython.ray.air.execution.resources.resource_manager.ResourceManager.request_resources(resource_request:ResourceRequest)
Request resources.
classpython.ray.air.integrations.comet.CometLoggerCallback
CometLoggerCallback for logging Tune results to Comet.
funcpython.ray.air.integrations.wandb.setup_wandb(config:Optional[Dict]=None, api_key:Optional[str]=None, api_key_file:Optional[str]=None, rank_zero_only:bool=True, **kwargs) -> Union[Run, RunDisabled]
Set up a Weights & Biases session.
classpython.ray.air.result.Result
The final result of a ML training run or a Tune trial.
methodpython.ray.air.result.Result.config() -> Optional[Dict[str, Any]]
The config associated with the result.
classpython.ray.air.util.data_batch_conversion.BlockFormat
Internal Dataset block format enum.
classpython.ray.autoscaler._private.aliyun.utils.AcsClient
A wrapper around Aliyun SDK.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.allocate_public_address(instance_id:str) -> Optional[str]
Assign a public IP address to an ECS instance.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.authorize_security_group(ip_protocol:str, port_range:str, security_group_id:str, source_cidr_ip:str) -> None
Create an inbound security group rule.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.create_key_pair(key_pair_name:str) -> Optional[dict]
Create an SSH key pair.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.create_security_group(vpc_id:str) -> Optional[str]
Create a security group.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.create_vpc() -> Optional[str]
Create a virtual private cloud (VPC).
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.delete_key_pairs(key_pair_names:List[str]) -> None
Delete one or more SSH key pairs.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.describe_key_pairs(key_pair_name:Optional[str]=None) -> Optional[list]
Query one or more key pairs.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.describe_v_switches(vpc_id:Optional[str]=None) -> Optional[list]
Query one or more VSwitches.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.describe_vpcs() -> Optional[list]
Query one or more VPCs in a region.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.import_key_pair(key_pair_name:str, public_key_body:str) -> None
Import the public key of an RSA-encrypted key pair.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.start_instance(instance_id:str) -> None
Start an ECS instance.
methodpython.ray.autoscaler._private.aliyun.utils.AcsClient.stop_instance(instance_id:str, force_stop:bool=False) -> None
Stop an ECS instance that is in the Running state.
classpython.ray.autoscaler._private.autoscaler.StandardAutoscaler
The autoscaling control loop for a Ray cluster.
classpython.ray.autoscaler._private.cli_logger.SilentClickException
`ClickException` that does not print a message.
classpython.ray.autoscaler._private.cluster_dump.Node
Node (as in "machine")
funcpython.ray.autoscaler._private.cluster_dump.get_all_local_data(archive:Archive, parameters:GetParameters)
Get all local data.
funcpython.ray.autoscaler._private.cluster_dump.get_local_debug_state(archive:Archive, session_dir:str='/tmp/ray/session_latest') -> Archive
Copy local log files into an archive.
funcpython.ray.autoscaler._private.cluster_dump.get_local_ray_logs(archive:Archive, exclude:Optional[Sequence[str]]=None, session_log_dir:str='/tmp/ray/session_latest') -> Archive
Copy local log files into an archive.
funcpython.ray.autoscaler._private.commands.debug_status(status:bytes, error:bytes, verbose:bool=False, address:Optional[str]=None) -> str
Return a debug string for the autoscaler.
funcpython.ray.autoscaler._private.commands.kill_node(config_file:str, yes:bool, hard:bool, override_cluster_name:Optional[str]) -> Optional[str]
Kills a random Raylet worker.
funcpython.ray.autoscaler._private.commands.monitor_cluster(cluster_config_file:str, num_lines:int, override_cluster_name:Optional[str]) -> None
Tails the autoscaler logs of a Ray cluster.
funcpython.ray.autoscaler._private.docker.validate_docker_config(config:Dict[str, Any]) -> None
Checks whether the Docker configuration is valid.
funcpython.ray.autoscaler._private.gcp.config.get_node_type(node:dict) -> GCPNodeType
Returns node type based on the keys in ``node``.
classpython.ray.autoscaler._private.gcp.node.GCPCompute
Abstraction around GCP compute resource
classpython.ray.autoscaler._private.gcp.node.GCPComputeNode
Abstraction around compute nodes
classpython.ray.autoscaler._private.gcp.node.GCPNode
Abstraction around compute and tpu nodes
classpython.ray.autoscaler._private.gcp.node.GCPNodeType
Enum for GCP node types (compute & tpu)
methodpython.ray.autoscaler._private.gcp.node.GCPNodeType.name_to_type(name:str)
Provided a node name, determine the type.
classpython.ray.autoscaler._private.gcp.node.GCPResource
Abstraction around compute and TPU resources
methodpython.ray.autoscaler._private.gcp.node.GCPResource.create_instance(base_config:dict, labels:dict, wait_for_operation:bool=True) -> Tuple[dict, str]
Creates a single instance and returns result.
methodpython.ray.autoscaler._private.gcp.node.GCPResource.delete_instance(node_id:str, wait_for_operation:bool=True) -> dict
Deletes an instance and returns result.
methodpython.ray.autoscaler._private.gcp.node.GCPResource.get_instance(node_id:str) -> 'GCPNode'
Returns a single instance.
methodpython.ray.autoscaler._private.gcp.node.GCPResource.list_instances(label_filters:Optional[dict]=None, is_terminated:bool=False) -> List['GCPNode']
Returns a filtered list of all instances.
methodpython.ray.autoscaler._private.gcp.node.GCPResource.set_labels(node:GCPNode, labels:dict, wait_for_operation:bool=True) -> dict
Sets labels on an instance and returns result.
methodpython.ray.autoscaler._private.gcp.node.GCPResource.start_instance(node_id:str, wait_for_operation:bool=True) -> dict
Starts a single instance and returns result.
methodpython.ray.autoscaler._private.gcp.node.GCPResource.stop_instance(node_id:str, wait_for_operation:bool=True) -> dict
Deletes an instance and returns result.
classpython.ray.autoscaler._private.gcp.node.GCPTPU
Abstraction around GCP TPU resource
methodpython.ray.autoscaler._private.gcp.node.GCPTPU.wait_for_operation(operation:dict, max_polls:int=MAX_POLLS_TPU, poll_interval:int=POLL_INTERVAL) -> dict
Poll for TPU operation until finished.
classpython.ray.autoscaler._private.gcp.node.GCPTPUNode
Abstraction around tpu nodes
classpython.ray.autoscaler._private.gcp.tpu_command_runner.TPUCommandRunner
A TPU pod command runner.
methodpython.ray.autoscaler._private.gcp.tpu_command_runner.TPUCommandRunner.run_init(*args:Any, **kwargs:Any) -> Optional[bool]
Used to run extra initialization commands.
methodpython.ray.autoscaler._private.gcp.tpu_command_runner.TPUCommandRunner.run_rsync_down(*args:Any, **kwargs:Any) -> None
Rsync files down from the cluster node.
classpython.ray.autoscaler._private.kuberay.node_provider.IKubernetesHttpApiClient
An interface for a Kubernetes HTTP API client.
methodpython.ray.autoscaler._private.kuberay.node_provider.IKubernetesHttpApiClient.get(path:str) -> Dict[str, Any]
Wrapper for REST GET of resource with proper headers.
funcpython.ray.autoscaler._private.kuberay.node_provider.status_tag(pod:Dict[str, Any]) -> NodeStatus
Convert pod state to Ray autoscaler node status.
classpython.ray.autoscaler._private.load_metrics.LoadMetrics
Container for cluster load metrics.
funcpython.ray.autoscaler._private.load_metrics.add_resources(dict1:Dict[str, float], dict2:Dict[str, float]) -> Dict[str, float]
Add the values in two dictionaries.
classpython.ray.autoscaler._private.local.node_provider.LocalNodeProvider
NodeProvider for private/local clusters.
classpython.ray.autoscaler._private.monitor.Monitor
Autoscaling monitor.
methodpython.ray.autoscaler._private.monitor.Monitor.get_session_name(gcs_client:GcsClient) -> Optional[str]
Obtain the session name from the GCS.
classpython.ray.autoscaler._private.node_launcher.NodeLauncher
Launches nodes asynchronously in the background.
classpython.ray.autoscaler._private.node_tracker.NodeTracker
Map nodes to their corresponding logs.
methodpython.ray.autoscaler._private.node_tracker.NodeTracker.get_all_failed_node_info(non_failed_ids:Set[str]) -> List[Tuple[str, str]]
Get the information about all failed nodes.
methodpython.ray.autoscaler._private.node_tracker.NodeTracker.track(node_id:str, ip:str, node_type:str)
Begin to track a new node.
methodpython.ray.autoscaler._private.node_tracker.NodeTracker.untrack(node_id:str)
Gracefully stop tracking a node.
classpython.ray.autoscaler._private.spark.spark_job_server.SparkJobServer
High level design: 1.
funcpython.ray.autoscaler._private.util.base32hex(data:bytes) -> str
Encode bytes using base32hex, without padding and in lower case.
funcpython.ray.autoscaler._private.util.format_memory(mem_bytes:Number) -> str
Formats memory in bytes in friendly unit.
classpython.ray.autoscaler.batching_node_provider.ScaleRequest
Stores desired scale computed by the autoscaler.
classpython.ray.autoscaler.command_runner.CommandRunnerInterface
Interface to run commands on a remote cluster node.
methodpython.ray.autoscaler.command_runner.CommandRunnerInterface.run_init(*as_head:bool, *file_mounts:Dict[str, str], *sync_run_yet:bool) -> Optional[bool]
Used to run extra initialization commands.
methodpython.ray.autoscaler.command_runner.CommandRunnerInterface.run_rsync_down(source:str, target:str, options:Optional[Dict[str, Any]]=None) -> None
Rsync files down from the cluster node.
methodpython.ray.autoscaler.command_runner.CommandRunnerInterface.run_rsync_up(source:str, target:str, options:Optional[Dict[str, Any]]=None) -> None
Rsync files up to the cluster node.
classpython.ray.autoscaler.local.coordinator_server.Handler
A custom handler for OnPremCoordinatorServer.
methodpython.ray.autoscaler.local.coordinator_server.Handler.do_HEAD()
HTTP HEAD handler method.
classpython.ray.autoscaler.node_provider.NodeProvider
Interface for getting and returning nodes from a Cloud.
methodpython.ray.autoscaler.node_provider.NodeProvider.external_ip(node_id:str) -> str
Returns the external ip of the given node.
methodpython.ray.autoscaler.node_provider.NodeProvider.get_node_id(ip_address:str, use_internal_ip:bool=False) -> str
Returns the node_id given an IP address.
methodpython.ray.autoscaler.node_provider.NodeProvider.internal_ip(node_id:str) -> str
Returns the internal ip (Ray ip) of the given node.
methodpython.ray.autoscaler.node_provider.NodeProvider.is_readonly() -> bool
Returns whether this provider is readonly.
methodpython.ray.autoscaler.node_provider.NodeProvider.is_running(node_id:str) -> bool
Return whether the specified node is running.
methodpython.ray.autoscaler.node_provider.NodeProvider.is_terminated(node_id:str) -> bool
Return whether the specified node is terminated.
methodpython.ray.autoscaler.node_provider.NodeProvider.node_tags(node_id:str) -> Dict[str, str]
Returns the tags of the given node (string dict).
methodpython.ray.autoscaler.node_provider.NodeProvider.terminate_node(node_id:str) -> Optional[Dict[str, Any]]
Terminates the specified node.
methodpython.ray.autoscaler.node_provider.NodeProvider.terminate_nodes(node_ids:List[str]) -> Optional[Dict[str, Any]]
Terminates a set of nodes.
funcpython.ray.autoscaler.sdk.sdk.get_docker_host_mount_location(cluster_name:str) -> str
Return host path that Docker mounts attach to.
funcpython.ray.autoscaler.sdk.sdk.get_head_node_ip(cluster_config:Union[dict, str]) -> str
Returns head node IP for given configuration file if exists.
funcpython.ray.autoscaler.sdk.sdk.get_worker_node_ips(cluster_config:Union[dict, str]) -> List[str]
Returns worker node IPs for given configuration file.
classpython.ray.autoscaler.v2.event_logger.AutoscalerEventLogger
Logs events related to the autoscaler.

About this data

These signatures were extracted from the public source of ray-project/ray using Python's ast module. Argument names, default values, type annotations and return types are taken verbatim from the code. Implementation bodies are never stored. See how it works for details.

Back to all 805 libraries