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
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