class_docstr: The backend options for
  :class:`~torch.distributed.rpc.TensorPipeAgent`, derived from
  :class:`~torch.distributed.rpc.RpcBackendOptions`.
  
  Args:
      num_worker_threads (int, optional): The number of threads in the
          thread-pool used by
          :class:`~torch.distributed.rpc.TensorPipeAgent` to execute
          requests (default: 16).
      rpc_timeout (float, optional): The default timeout, in seconds,
          for RPC requests (default: 60 seconds). If the RPC has not
          completed in this timeframe, an exception indicating so will
          be raised. Callers can override this timeout for individual
          RPCs in :meth:`~torch.distributed.rpc.rpc_sync` and
          :meth:`~torch.distributed.rpc.rpc_async` if necessary.
      init_method (str, optional): The URL to initialize the distributed
          store used for rendezvous. It takes any value accepted for the
          same argument of :meth:`~torch.distributed.init_process_group`
          (default: ``env://``).
      device_maps (Dict[str, Dict], optional): Device placement mappings from
          this worker to the callee. Key is the callee worker name and value
          the dictionary (``Dict`` of ``int``, ``str``, or ``torch.device``)
          that maps this worker's devices to the callee worker's devices.
          (default: ``None``)
      devices (List[int, str, or ``torch.device``], optional): all local
          CUDA devices used by RPC agent. By Default, it will be initialized
          to all local devices from its own ``device_maps`` and corresponding
          devices from its peers' ``device_maps``. When processing CUDA RPC
          requests, the agent will properly synchronize CUDA streams for
          all devices in this ``List``.
code: def __init__(
      self,
      *,
      num_worker_threads: int = rpc_contants.DEFAULT_NUM_WORKER_THREADS,
      rpc_timeout: float = rpc_contants.DEFAULT_RPC_TIMEOUT_SEC,
      init_method: str = rpc_contants.DEFAULT_INIT_METHOD,
      device_maps: Optional[
          Dict[str, Dict[DeviceType, DeviceType]]
      ] = None,
      devices: Optional[List[DeviceType]] = None,
      _transports: Optional[List] = None,
      _channels: Optional[List] = None,
  ):
      full_device_maps = (
          {}
          if device_maps is None
          else {k: _to_device_map(v) for k, v in device_maps.items()}
      )
      full_device_list = (
          [] if devices is None else _to_device_list(devices)
      )
      super().__init__(
          num_worker_threads,
          _transports,
          _channels,
          rpc_timeout,
          init_method,
          full_device_maps,
          full_device_list,
      )
  
file_path: pytorch/torch/distributed/rpc/options.py
imports: from typing import Dict, List, Optional, Union
  import torch
  from torch._C._distributed_rpc import _TensorPipeRpcBackendOptionsBase
  from .None import constants
label_desc: Use image node_id 1 to create a new TensorPipeRpcBackendOptions object from inherited base classes: _TensorPipeRpcBackendOptionsBase with example: obj = TensorPipeRpcBackendOptions()