code: def run_resume_flow(
      experiment_name: str,
      indicator_file: str,
      no_syncer: bool,
      storage_path: Optional[str],
      first_run_time: int = 33,
      second_run_time: int = 33,
      run_start_timeout: int = 30,
      before_experiments_callback: Optional[Callable[[], None]] = None,
      between_experiments_callback: Optional[Callable[[], None]] = None,
      after_experiments_callback: Optional[Callable[[], None]] = None,
  ):
      """Run full flow, i.e.
  
      - Clean up existing experiment dir
      - Call before experiment callback
      - Run tune script for `first_run_time` seconds
      - Call between experiment callback
      - Run tune script for another `second_run_time` seconds
      - Call after experiment callback
      """
      # Cleanup ~/ray_results/<experiment_name> folder
      cleanup_driver_experiment_dir(experiment_name)
  
      # Cleanup experiment folder on remote nodes
      cleanup_remote_node_experiment_dir(experiment_name)
  
      # Run before experiment callbacks
      if before_experiments_callback:
          print("Before experiments: Invoking callback")
          before_experiments_callback()
          print("Before experiments: Callback completed")
  
      # Delete indicator file
      delete_file_if_exists(indicator_file)
  
      # Run tune script for `first_run_time` seconds
      run_tune_script_for_time(
          run_time=first_run_time,
          experiment_name=experiment_name,
          indicator_file=indicator_file,
          no_syncer=no_syncer,
          storage_path=storage_path,
          run_start_timeout=run_start_timeout,
      )
  
      # Before we restart, run a couple of checks
      # Run before experiment callbacks
      if between_experiments_callback:
          print("Between experiments: Invoking callback")
          between_experiments_callback()
          print("Between experiments: Callback completed")
  
      # Restart. First, clean up indicator file
      delete_file_if_exists(indicator_file)
  
      # Start run again, run for another `second_run_time` seconds
      run_tune_script_for_time(
          run_time=second_run_time,
          experiment_name=experiment_name,
          indicator_file=indicator_file,
          no_syncer=no_syncer,
          storage_path=storage_path,
      )
  
      if after_experiments_callback:
          print("After experiments: Invoking callback")
          after_experiments_callback()
          print("After experiments: Callback completed")
  
imports: import argparse
  import csv
  import io
  import tarfile
  from dataclasses import dataclass
  import json
  import os
  import pickle
  import platform
  import re
  import shutil
  import signal
  import subprocess
  import tempfile
  import time
  from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
  import ray
  from ray.train._internal.storage import StorageContext
  from ray.tune.execution.experiment_state import _find_newest_experiment_checkpoint
  from ray.tune.result import _get_defaults_results_dir
  from ray.tune.utils.serialization import TuneFunctionDecoder
label_desc: Use image node_id 10 for calling a global function with example usage: run_resume_flow(experiment_name, indicator_file, no_syncer, storage_path, first_run_time, second_run_time, run_start_timeout, before_experiments_callback, between_experiments_callback, after_experiments_callback) without return types