brk-code

ray の API リファレンス

ray (ray-project/ray) の公開 API 400 件 —— クラス 104、関数 154、メソッド 142。実際のソースを静的解析して抽出した正確なシグネチャを掲載しています。

リポジトリ: ray-project/ray

種別件数
クラス104
関数154
メソッド142

API 一覧

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.

この情報について

掲載しているシグネチャは ray-project/ray の公開ソースコードを Python の ast モジュールで静的解析し、引数名・デフォルト値・ 型注釈・戻り値型をそのまま抽出したものです。実装コードは保存していません。 詳しくは仕組みの解説をご覧ください。

収録ライブラリ一覧（全 805 件）へ戻る