code: def _cached_call(self, args, kwargs, shelving=False):
      func_id, args_id = self._get_output_identifiers(*args, **kwargs)
      metadata = None
      msg = None
  
      # Whether or not the memorized function must be called
      must_call = False
  
      # FIXME: The statements below should be try/excepted
      # Compare the function code with the previous to see if the
      # function code has changed
      if not (
          self._check_previous_func_code(stacklevel=4)
          and self.store_backend.contains_item([func_id, args_id])
      ):
          if self._verbose > 10:
              _, name = get_func_name(self.func)
              self.warn(
                  "Computing func {0}, argument hash {1} "
                  "in location {2}".format(
                      name,
                      args_id,
                      self.store_backend.get_cached_func_info(
                          [func_id]
                      )["location"],
                  )
              )
          must_call = True
      else:
          try:
              t0 = time.time()
              if self._verbose:
                  msg = _format_load_msg(
                      func_id,
                      args_id,
                      timestamp=self.timestamp,
                      metadata=metadata,
                  )
  
              if not shelving:
                  # When shelving, we do not need to load the output
                  out = self.store_backend.load_item(
                      [func_id, args_id], msg=msg, verbose=self._verbose
                  )
              else:
                  out = None
  
              if self._verbose > 4:
                  t = time.time() - t0
                  _, name = get_func_name(self.func)
                  msg = "%s cache loaded - %s" % (name, format_time(t))
                  print(max(0, (80 - len(msg))) * "_" + msg)
          except Exception:
              # XXX: Should use an exception logger
              _, signature = format_signature(
                  self.func, *args, **kwargs
              )
              self.warn(
                  "Exception while loading results for "
                  "{}\n {}".format(signature, traceback.format_exc())
              )
  
              must_call = True
  
      if must_call:
          # PYCARET CHANGES
          self._cached_output_identifiers = func_id, args_id
          out, metadata = self.call(*args, **kwargs)
          if self.mmap_mode is not None and metadata is not None:
              # PYCARET CHANGES END
              # Memmap the output at the first call to be consistent with
              # later calls
              if self._verbose:
                  msg = _format_load_msg(
                      func_id,
                      args_id,
                      timestamp=self.timestamp,
                      metadata=metadata,
                  )
              out = self.store_backend.load_item(
                  [func_id, args_id], msg=msg, verbose=self._verbose
              )
  
      return (out, args_id, metadata)
  
imports: import hashlib
  import pickle
  import struct
  import sys
  import tempfile
  import time
  import traceback
  from pathlib import Path
  from typing import TYPE_CHECKING, Union
  from joblib.hashing import Hasher, Pickler
  from joblib.memory import MemorizedFunc, MemorizedResult, Memory, NotMemorizedResult, _format_load_msg, filter_args, format_call, format_signature, format_time, get_func_name
  from xxhash import xxh128
label_desc: Use image node_id 4 for calling the FastMemorizedFunc obj's underlying member method code with example usage: obj._cached_call(args, kwargs, shelving) and returns: out,  args_id,  metadata