class_docstr: PipelineEngine class that computes each term independently.
  
  Parameters
  ----------
  get_loader : callable
      A function that is given a loadable term and returns a PipelineLoader
      to use to retrieve raw data for that term.
  calendar : DatetimeIndex
      Array of dates to consider as trading days when computing a range
      between a fixed start and end.
  asset_finder : catalyst.assets.AssetFinder
      An AssetFinder instance.  We depend on the AssetFinder to determine
      which assets are in the top-level universe at any point in time.
  populate_initial_workspace : callable, optional
      A function which will be used to populate the initial workspace when
      computing a pipeline. See
      :func:`catalyst.pipeline.engine.default_populate_initial_workspace`
      for more info.
  
  See Also
  --------
  :func:`catalyst.pipeline.engine.default_populate_initial_workspace`
docstr: Compute inputs for the given term.
  
  This is mostly complicated by the fact that for each input we store as
  many rows as will be necessary to serve **any** computation requiring
  that input.
docstr_tok: ["Compute","inputs","for","the","given","term",".","This","is","mostly","complicated","by","the","fact","that","for","each","input","we","store","as","many","rows","as","will","be","necessary","to","serve","*","*","any","*","*","computation","requiring","that","input","."]
code: def _inputs_for_term(term, workspace, graph):
      """
      Compute inputs for the given term.
  
      This is mostly complicated by the fact that for each input we store as
      many rows as will be necessary to serve **any** computation requiring
      that input.
      """
      offsets = graph.offset
      out = []
      if term.windowed:
          # If term is windowed, then all input data should be instances of
          # AdjustedArray.
          for input_ in term.inputs:
              adjusted_array = ensure_adjusted_array(
                  workspace[input_],
                  input_.missing_value,
              )
              out.append(
                  adjusted_array.traverse(
                      window_length=term.window_length,
                      offset=offsets[term, input_],
                  )
              )
      else:
          # If term is not windowed, input_data may be an AdjustedArray or
          # np.ndarray.  Coerce the former to the latter.
          for input_ in term.inputs:
              input_data = ensure_ndarray(workspace[input_])
              offset = offsets[term, input_]
              # OPTIMIZATION: Don't make a copy by doing input_data[0:] if
              # offset is zero.
              if offset:
                  input_data = input_data[offset:]
              out.append(input_data)
      return out
  
imports: from abc import ABCMeta, abstractmethod
  from uuid import uuid4
  import six
  from six import iteritems, with_metaclass
  from numpy import array
  from pandas import DataFrame, MultiIndex
  from toolz import groupby, juxt
  from toolz.curried.operator import getitem
  from catalyst.lib.adjusted_array import ensure_adjusted_array, ensure_ndarray
  from catalyst.errors import NoFurtherDataError
  from catalyst.utils.numpy_utils import as_column, repeat_first_axis, repeat_last_axis
  from catalyst.utils.pandas_utils import explode
  from .term import AssetExists, InputDates, LoadableTerm
  from catalyst.utils.date_utils import compute_date_range_chunks
  from catalyst.utils.pandas_utils import categorical_df_concat
  from catalyst.utils.sharedoc import copydoc
label_desc: Use image node_id 5 for calling the SimplePipelineEngine obj's underlying member method code with example usage: obj._inputs_for_term(term, workspace, graph) and returns: out