code: def _process_modify_op(
      self,
      expected_type: _DataType,
      op: Operation,
      modifier: Callable[[List[Operation], Operation], List[Operation]],
  ) -> None:
      if self._type and self._type != expected_type:
          # This case should never happen since inconsistencies on data types are verified on user api.
          # So such operations should not appear in the queue without delete operation between them.
          # Still we want to support this case to avoid some unclear dependencies and assumptions.
          self._errors.append(
              MetadataInconsistency(
                  "Cannot perform {} operation on {}: Attribute is not a {}".format(
                      op.__class__.__name__,
                      path_to_str(self._path),
                      expected_type.value,
                  )
              )
          )
      else:
          self._check_prerequisites(op)
          self._type = expected_type
          self._modify_ops = modifier(self._modify_ops, op)
  
imports: import dataclasses
  import typing
  from enum import Enum
  from typing import Callable, List, TypeVar
  from neptune.common.exceptions import InternalClientError
  from neptune.exceptions import MetadataInconsistency
  from neptune.internal.operation import AddStrings, AssignArtifact, AssignBool, AssignDatetime, AssignFloat, AssignInt, AssignString, ClearFloatLog, ClearImageLog, ClearStringLog, ClearStringSet, ConfigFloatSeries, CopyAttribute, DeleteAttribute, DeleteFiles, LogFloats, LogImages, LogStrings, Operation, RemoveStrings, TrackFilesToArtifact, UploadFile, UploadFileContent, UploadFileSet
  from neptune.internal.operation_visitor import OperationVisitor
  from neptune.internal.utils.paths import path_to_str
label_desc: Use image node_id 5 for calling the _OperationsAccumulator obj's underlying member method code with example usage: obj._process_modify_op(expected_type, op, modifier) without return types