code: def __init__(
      self,
      container_id: "UniqueId",
      container_type: "ContainerType",
      backend: "NeptuneBackend",
      lock: threading.RLock,
      queue: "Queue[Signal]",
      sleep_time: float = 5,
      batch_size: int = 1000,
      data_path: Optional[Path] = None,
      should_print_logs: bool = True,
  ):
      self._should_print_logs: bool = should_print_logs
      self._data_path = (
          data_path
          if data_path
          else self._init_data_path(container_id, container_type)
      )
      self._metadata_file = MetadataFile(
          data_path=self._data_path,
          metadata=common_metadata(
              mode="async",
              container_id=container_id,
              container_type=container_type,
          ),
      )
      self._operation_storage = OperationStorage(
          data_path=self._data_path
      )
  
      serializer: Callable[
          [Operation], Dict[str, Any]
      ] = lambda op: op.to_dict()
      self._queue = DiskQueue(
          dir_path=self._operation_storage.data_path,
          to_dict=serializer,
          from_dict=Operation.from_dict,
          lock=lock,
      )
  
      self._container_id: "UniqueId" = container_id
      self._container_type: "ContainerType" = container_type
      self._backend: "NeptuneBackend" = backend
      self._batch_size: int = batch_size
      self._last_version: int = 0
      self._consumed_version: int = 0
      self._consumer: Daemon = self.ConsumerThread(
          self, sleep_time, batch_size
      )
      self._lock: threading.RLock = lock
      self._signals_queue: "Queue[Signal]" = queue
      self._accepts_operations: bool = True
  
      # Caller is responsible for taking this lock
      self._waiting_cond = threading.Condition(lock=lock)
  
imports: import os
  import threading
  from datetime import datetime
  from pathlib import Path
  from queue import Queue
  from time import monotonic, time
  from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
  from neptune.common.exceptions import NeptuneException
  from neptune.common.warnings import NeptuneWarning, warn_once
  from neptune.constants import ASYNC_DIRECTORY
  from neptune.envs import NEPTUNE_SYNC_AFTER_STOP_TIMEOUT
  from neptune.exceptions import NeptuneSynchronizationAlreadyStoppedException
  from neptune.internal.disk_queue import DiskQueue
  from neptune.internal.init.parameters import DEFAULT_STOP_TIMEOUT
  from neptune.internal.metadata_file import MetadataFile
  from neptune.internal.operation import Operation
  from neptune.internal.operation_processors.operation_processor import OperationProcessor
  from neptune.internal.operation_processors.operation_storage import OperationStorage, get_container_dir
  from neptune.internal.operation_processors.utils import common_metadata
  from neptune.internal.signals_processing.utils import signal_batch_lag, signal_batch_processed, signal_batch_started
  from neptune.internal.threading.daemon import Daemon
  from neptune.internal.utils.disk_utilization import ensure_disk_not_overutilize
  from neptune.internal.utils.files import should_clean_internal_data
  from neptune.internal.utils.logger import logger
label_desc: Use image node_id 1 to create a new AsyncOperationProcessor object from inherited base classes: OperationProcessor with example: obj = AsyncOperationProcessor(container_id, container_type, backend, lock, queue, sleep_time, batch_size, data_path, should_print_logs)