docs: def get(self, name, interval, **kwargs):
      '''
      Get the set of values for a named timeseries and interval. If timestamp
      supplied, will fetch data for the period of time in which that timestamp
      would have fallen, else returns data for "now". If the timeseries
      resolution was not defined, then returns a simple list of values for the
      interval, else returns an ordered dict where the keys define the resolution
      interval and the values are the time series data in that (sub)interval.
      This allows the user to interpolate sparse data sets.
  
      If transform is defined, will utilize one of `[mean, count, min, max, sum]`
      to process each row of data returned. If the transform is a callable, will
      pass an array of data to the function. Note that the transform will be run
      after the data is condensed. If the transform is a list, then each row will
      return a hash of the form { transform_name_or_func : transformed_data }.
      If the transform is a hash, then it should be of the form
      { transform_name : transform_func } and will return the same structure as
      a list argument.
  
      Raises UnknownInterval if `interval` is not one of the configured
      intervals.
  
      TODO: Fix this method doc
      '''
      config = self._intervals.get(interval)
      if not config:
        raise UnknownInterval(interval)
  
      timestamp = kwargs.get('timestamp', time.time())
      fetch = kwargs.get('fetch')
      process_row = kwargs.get('process_row') or self._process_row
      condense = kwargs.get('condense', False)
      join_rows = kwargs.get('join_rows') or self._join
      transform = kwargs.get('transform')
  
      # DEPRECATED handle the deprecated version of condense
      condense = kwargs.get('condensed',condense)
  
      # If name is a list, then join all of results. It is more efficient to
      # use a single data structure and join "in-line" but that requires a major
      # refactor of the backends, so trying this solution to start with. At a
      # minimum we'd have to rebuild the results anyway because of the potential
      # for sparse data points would result in an out-of-order result.
      if isinstance(name, (list,tuple,set)):
        results = [ self._get(x, interval, config, timestamp, fetch=fetch, process_row=process_row) for x in name ]
        # Even resolution data is "coarse" in that it's not nested
        rval = self._join_results( results, True, join_rows )
      else:
        rval = self._get( name, interval, config, timestamp, fetch=fetch, process_row=process_row )
  
      # If condensed, collapse the result into a single row. Adjust the step_size
      # calculation to match.
      if config['coarse']:
        step_size = config['i_calc'].step_size(timestamp)
      else:
        step_size = config['r_calc'].step_size(timestamp)
      if condense and not config['coarse']:
        condense = condense if callable(condense) else self._condense
        rval = { config['i_calc'].normalize(timestamp) : condense(rval) }
        step_size = config['i_calc'].step_size(timestamp)
  
      if transform:
        for k,v in rval.items():
          rval[k] = self._process_transform(v, transform, step_size)
      return rval