code: def sync_single_execution(
      self,
      execution_path: Path,
      container_id: UniqueId,
      container_type: ContainerType,
  ) -> None:
      operation_storage = OperationStorage(execution_path)
      serializer: Callable[
          [Operation], Dict[str, Any]
      ] = lambda op: op.to_dict()
  
      with DiskQueue(
          dir_path=execution_path,
          to_dict=serializer,
          from_dict=Operation.from_dict,
          lock=threading.RLock(),
      ) as disk_queue:
          while True:
              batch = disk_queue.get_batch(1000)
              if not batch:
                  break
              version = batch[-1].ver
              batch = [element.obj for element in batch]
  
              start_time = time.monotonic()
              expected_count = len(batch)
              version_to_ack = version - expected_count
              while True:
                  try:
                      (
                          processed_count,
                          _,
                      ) = self._backend.execute_operations(
                          container_id=container_id,
                          container_type=container_type,
                          operations=batch,
                          operation_storage=operation_storage,
                      )
                      version_to_ack += processed_count
                      batch = batch[processed_count:]
                      disk_queue.ack(version)
                      if version_to_ack == version:
                          break
                  except NeptuneConnectionLostException as ex:
                      if (
                          time.monotonic() - start_time
                          > retries_timeout
                      ):
                          raise ex
                      logger.warning(
                          "Experiencing connection interruptions."
                          " Will try to reestablish communication with Neptune."
                          " Internal exception was: %s",
                          ex.cause.__class__.__name__,
                      )
  
imports: import logging
  import os
  import threading
  import time
  from pathlib import Path
  from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence
  from neptune.cli.abstract_backend_runner import AbstractBackendRunner
  from neptune.cli.utils import get_metadata_container, get_offline_dirs, get_project, get_qualified_name, is_container_synced_and_remove_junk, iterate_containers, split_dir_name
  from neptune.common.exceptions import NeptuneConnectionLostException
  from neptune.constants import ASYNC_DIRECTORY, OFFLINE_DIRECTORY, OFFLINE_NAME_PREFIX
  from neptune.envs import NEPTUNE_SYNC_BATCH_TIMEOUT_ENV
  from neptune.exceptions import CannotSynchronizeOfflineRunsWithoutProject
  from neptune.internal.backends.api_model import ApiExperiment, Project
  from neptune.internal.container_type import ContainerType
  from neptune.internal.disk_queue import DiskQueue
  from neptune.internal.id_formats import QualifiedName, UniqueId
  from neptune.internal.operation import Operation
  from neptune.internal.operation_processors.operation_storage import OperationStorage
  from neptune.internal.utils.logger import logger
label_desc: Use image node_id 3 for calling the SyncRunner obj's underlying member method code with example usage: obj.sync_single_execution(execution_path, container_id, container_type) without return types