code: def _cache(self, func, func_memory_level=1, **kwargs):
          
  
          verbose = getattr(self, 'verbose', 0)
  
          # Creates attributes if they don't exist
          # This is to make creating them in __init__() optional.
          if not hasattr(self, "memory_level"):
              self.memory_level = 0
          if not hasattr(self, "memory"):
              self.memory = Memory(cachedir=None, verbose=verbose)
          if isinstance(self.memory, _basestring):
              self.memory = Memory(cachedir=self.memory, verbose=verbose)
  
          # If cache level is 0 but a memory object has been provided, set
          # memory_level to 1 with a warning.
          if self.memory_level == 0:
              if (isinstance(self.memory, _basestring)
                      or self.memory.cachedir is not None):
                  warnings.warn("memory_level is currently set to 0 but "
                                "a Memory object has been provided. "
                                "Setting memory_level to 1.")
                  self.memory_level = 1
  
          return cache(func, self.memory, func_memory_level=func_memory_level,
                       memory_level=self.memory_level, **kwargs)
docs: Return a joblib.Memory object.
  
          The memory_level determines the level above which the wrapped
          function output is cached. By specifying a numeric value for
          this level, the user can to control the amount of cache memory
          used. This function will cache the function call or not
          depending on the cache level.
  
          Parameters
          ----------
          func: function
              The function the output of which is to be cached.
  
          memory_level: int
              The memory_level from which caching must be enabled for the wrapped
              function.
  
          Returns
          -------
          mem: joblib.Memory
              object that wraps the function func. This object may be
              a no-op, if the requested level is lower than the value given
              to _cache()). For consistency, a joblib.Memory object is always
              returned.