class_docstr: Dynamically applies a callable to the Elements in any HoloViews
  object. Will return a DynamicMap wrapping the original map object,
  which will lazily evaluate when a key is requested. By default
  Dynamic applies a no-op, making it useful for converting HoloMaps
  to a DynamicMap.
  
  Any supplied kwargs will be passed to the callable and any streams
  will be instantiated on the returned DynamicMap. If the supplied
  operation is a method on a parameterized object which was
  decorated with parameter dependencies Dynamic will automatically
  create a stream to watch the parameter changes. This default
  behavior may be disabled by setting watch=False.
docstr: Generate function to dynamically apply the operation.
  Wraps an existing HoloMap or DynamicMap.
docstr_tok: ["Generate","function","to","dynamically","apply","the","operation",".","Wraps","an","existing","HoloMap","or","DynamicMap","."]
code: def _dynamic_operation(self, map_obj):
      """
      Generate function to dynamically apply the operation.
      Wraps an existing HoloMap or DynamicMap.
      """
  
      def resolve(key, kwargs):
          if not isinstance(map_obj, HoloMap):
              return key, map_obj
          elif (
              isinstance(map_obj, DynamicMap)
              and map_obj._posarg_keys
              and not key
          ):
              key = tuple(kwargs[k] for k in map_obj._posarg_keys)
          return key, map_obj[key]
  
      def apply(element, *key, **kwargs):
          kwargs = dict(
              util.resolve_dependent_kwargs(self.p.kwargs), **kwargs
          )
          processed = self._process(element, key, kwargs)
          if (
              self.p.link_dataset
              and isinstance(element, Dataset)
              and isinstance(processed, Dataset)
              and processed._dataset is None
          ):
              processed._dataset = element.dataset
          return processed
  
      def dynamic_operation(*key, **kwargs):
          key, obj = resolve(key, kwargs)
          return apply(obj, *key, **kwargs)
  
      operation = self.p.operation
      op_kwargs = self.p.kwargs
      if not isinstance(operation, Operation):
          operation = function.instance(fn=apply)
          op_kwargs = {"kwargs": op_kwargs}
      return OperationCallable(
          dynamic_operation,
          inputs=[map_obj],
          link_inputs=self.p.link_inputs,
          operation=operation,
          operation_kwargs=op_kwargs,
      )
  
imports: import inspect
  import os
  import shutil
  import sys
  from collections import defaultdict
  from inspect import Parameter, Signature
  from pathlib import Path
  from types import FunctionType
  import param
  from pyviz_comms import extension
  from ..core import Dataset, Dimensioned, DynamicMap, HoloMap, Store, StoreOptions, ViewableElement, util
  from ..core.operation import Operation, OperationCallable
  from ..core.options import Keywords, Options, options_policy
  from ..core.overlay import Overlay
  from ..core.util import merge_options_to_dict
  from ..operation.element import function
  from ..streams import Params, Stream, streams_list_from_dict
  from .settings import OutputSettings, list_backends, list_formats
label_desc: Use image node_id 4 for calling the Dynamic obj's underlying member method code with example usage: obj._dynamic_operation(map_obj) and returns: OperationCallable, key,  map_obj, processed, apply, key,  map_obj