docs: def transform(self, stims, validation='strict', *args, **kwargs):
          ''' Executes the transformation on the passed stim(s).
  
          Args:
              stims (str, Stim, list): One or more stimuli to process. Must be
                  one of:
  
                      - A string giving the path to a file that can be read in
                        as a Stim (e.g., a .txt file, .jpg image, etc.)
                      - A Stim instance of any type.
                      - An iterable of stims, where each element is either a
                        string or a Stim.
  
              validation (str): String specifying how validation errors should
                  be handled. Must be one of:
  
                      - 'strict': Raise an exception on any validation error
                      - 'warn': Issue a warning for all validation errors
                      - 'loose': Silently ignore all validation errors
  
              args: Optional positional arguments to pass onto the internal
                  _transform call.
              kwargs: Optional positional arguments to pass onto the internal
                  _transform call.
          '''
  
          if isinstance(stims, string_types):
              stims = load_stims(stims)
  
          # If stims is a CompoundStim and the Transformer is expecting a single
          # input type, extract all matching stims
          if isinstance(stims, CompoundStim) and not isinstance(self._input_type, tuple):
              stims = stims.get_stim(self._input_type, return_all=True)
              if not stims:
                  raise ValueError("No stims of class %s found in the provided"
                                   "CompoundStim instance." % self._input_type)
  
          # If stims is an iterable, naively loop over elements, removing
          # invalid results if needed
          if isiterable(stims):
              iters = self._iterate(stims, validation=validation, *args,
                                    **kwargs)
              if config.get_option('drop_bad_extractor_results'):
                  iters = (i for i in iters if i is not None)
              iters = progress_bar_wrapper(iters, desc='Stim')
              return set_iterable_type(iters)
  
          # Validate stim, and then either pass it directly to the Transformer
          # or, if a conversion occurred, recurse.
          else:
              try:
                  validated_stim = self._validate(stims)
              except TypeError as err:
                  if validation == 'strict':
                      raise err
                  elif validation == 'warn':
                      logging.warn(str(err))
                      return
                  elif validation == 'loose':
                      return
              # If a conversion occurred during validation, we recurse
              if stims is not validated_stim:
                  return self.transform(validated_stim, *args, **kwargs)
              else:
                  result = self._transform(validated_stim, *args, **kwargs)
                  result = _log_transformation(validated_stim, result, self)
                  if isgenerator(result):
                      result = list(result)
                  self._propagate_context(validated_stim, result)
                  return result