class_docstr: The real implementation behind external facing ``Tuner``.
  
  The external facing ``Tuner`` multiplexes between local Tuner and remote Tuner
  depending on whether in Ray client mode.
  
  In Ray client mode, external ``Tuner`` wraps ``TunerInternal`` into a remote actor,
  which is guaranteed to be placed on head node.
  
  ``TunerInternal`` can be constructed from fresh, in which case, ``trainable`` needs
  to be provided, together with optional ``param_space``, ``tune_config`` and
  ``run_config``.
  
  It can also be restored from a previous failed run (given ``restore_path``).
  
  Args:
      restore_path: The path from where the Tuner can be restored. If provided, None
          of the rest args are needed.
      resume_config: Resume config to configure which trials to continue.
      trainable: The trainable to be tuned.
      param_space: Search space of the tuning job.
          One thing to note is that both preprocessor and dataset can be tuned here.
      tune_config: Tuning algorithm specific configs.
          Refer to ray.tune.tune_config.TuneConfig for more info.
      run_config: Runtime configuration that is specific to individual trials.
          If passed, this will overwrite the run config passed to the Trainer,
          if applicable. Refer to ray.train.RunConfig for more info.
code: def _restore_from_path_or_uri(
      self,
      path_or_uri: str,
      trainable: TrainableTypeOrTrainer,
      overwrite_param_space: Optional[Dict[str, Any]],
      resume_config: _ResumeConfig,
      storage_filesystem: Optional[pyarrow.fs.FileSystem],
  ):
      fs, fs_path = get_fs_and_path(path_or_uri, storage_filesystem)
      with fs.open_input_file(os.path.join(fs_path, _TUNER_PKL)) as f:
          tuner_state = pickle.loads(f.readall())
  
      (
          old_trainable_name,
          flattened_param_space_keys,
      ) = self._load_tuner_state(tuner_state)
  
      # Perform validation and set the re-specified `trainable` and `param_space`
      self._set_trainable_on_restore(
          trainable=trainable, old_trainable_name=old_trainable_name
      )
      self._set_param_space_on_restore(
          param_space=overwrite_param_space,
          flattened_param_space_keys=flattened_param_space_keys,
      )
  
      # Update RunConfig to reflect changes in the experiment directory
      path_or_uri_obj = URI(path_or_uri)
  
      # Infer the `storage_path` and run `name` of the restored run using the
      # experiment directory.
      # Ex: ~/ray_results/exp_name -> ~/ray_results, exp_name
      # Ex: s3://bucket/exp_name -> s3://bucket, exp_name
      self._run_config.name = path_or_uri_obj.name
      self._run_config.storage_path = str(path_or_uri_obj.parent)
  
      (
          self._local_experiment_dir,
          self._experiment_dir_name,
      ) = self.setup_create_experiment_checkpoint_dir(
          self.converted_trainable, self._run_config
      )
  
      # Load the experiment results at the point where it left off.
      try:
          self._experiment_analysis = ExperimentAnalysis(
              experiment_checkpoint_path=path_or_uri,
              default_metric=self._tune_config.metric,
              default_mode=self._tune_config.mode,
          )
      except Exception:
          self._experiment_analysis = None
  
      self._resume_config = resume_config
      self._is_restored = True
  
imports: import copy
  import io
  import os
  import math
  import logging
  from pathlib import Path
  from typing import Any, Callable, Dict, List, Optional, Type, Union, TYPE_CHECKING, Tuple
  import pyarrow.fs
  import ray.cloudpickle
  from ray.util import inspect_serializability
  from ray.air._internal.uri_utils import URI
  from ray.air._internal.usage import AirEntrypoint
  from ray.air.config import RunConfig, ScalingConfig
  from ray.train._internal.storage import StorageContext, get_fs_and_path
  from ray.tune import Experiment, TuneError, ExperimentAnalysis
  from ray.tune.execution.experiment_state import _ResumeConfig
  from ray.tune.tune import _Config
  from ray.tune.registry import is_function_trainable
  from ray.tune.result import _get_defaults_results_dir
  from ray.tune.result_grid import ResultGrid
  from ray.tune.trainable import Trainable
  from ray.tune.tune import run
  from ray.tune.tune_config import TuneConfig
  from ray.tune.utils import flatten_dict
label_desc: Use image node_id 11 for calling the TunerInternal obj's underlying member method code with example usage: obj._restore_from_path_or_uri(path_or_uri, trainable, overwrite_param_space, resume_config, storage_filesystem) without return types