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.
  asset_finder : zipline.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:`zipline.pipeline.engine.default_populate_initial_workspace`
      for more info.
  default_hooks : list, optional
      List of hooks that should be used to instrument all pipelines executed
      by this engine.
  
  See Also
  --------
  :func:`zipline.pipeline.engine.default_populate_initial_workspace`
class_docstr_tok: ["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",".","asset_finder",":","zipline.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",":","`","zipline.pipeline.engine.default_populate_initial_workspace","`","for","more","info",".","default_hooks",":","list",",","optional","List","of","hooks","that","should","be","used","to","instrument","all","pipelines","executed","by","this","engine",".","See","Also","--","--","--","--",":","func",":","`","zipline.pipeline.engine.default_populate_initial_workspace","`"]
docstr: Verify that the values passed to compute_chunk are well-formed.
docstr_tok: ["Verify","that","the","values","passed","to","compute_chunk","are","well-formed","."]
code: def _validate_compute_chunk_params(
      self, graph, dates, sids, initial_workspace
  ):
      """
      Verify that the values passed to compute_chunk are well-formed.
      """
      root = self._root_mask_term
      clsname = type(self).__name__
  
      # Writing this out explicitly so this errors in testing if we change
      # the name without updating this line.
      compute_chunk_name = self.compute_chunk.__name__
      if root not in initial_workspace:
          raise AssertionError(
              "root_mask values not supplied to {cls}.{method}".format(
                  cls=clsname,
                  method=compute_chunk_name,
              )
          )
  
      shape = initial_workspace[root].shape
      implied_shape = len(dates), len(sids)
      if shape != implied_shape:
          raise AssertionError(
              "root_mask shape is {shape}, but received dates/assets "
              "imply that shape should be {implied}".format(
                  shape=shape,
                  implied=implied_shape,
              )
          )
  
      for term in initial_workspace:
          if self._is_special_root_term(term):
              continue
  
          if term.domain is GENERIC:
              # XXX: We really shouldn't allow **any** generic terms to be
              # populated in the initial workspace. A generic term, by
              # definition, can't correspond to concrete data until it's
              # paired with a domain, and populate_initial_workspace isn't
              # given the domain of execution, so it can't possibly know what
              # data to use when populating a generic term.
              #
              # In our current implementation, however, we don't have a good
              # way to represent specializations of ComputableTerms that take
              # only generic inputs, so there's no good way for the initial
              # workspace to provide data for such terms except by populating
              # the generic ComputableTerm.
              #
              # The right fix for the above is to implement "full
              # specialization", i.e., implementing ``specialize`` uniformly
              # across all terms, not just LoadableTerms. Having full
              # specialization will also remove the need for all of the
              # remaining ``maybe_specialize`` calls floating around in this
              # file.
              #
              # In the meantime, disallowing ComputableTerms in the initial
              # workspace would break almost every test in
              # `test_filter`/`test_factor`/`test_classifier`, and fixing
              # them would require updating all those tests to compute with
              # more specialized terms. Once we have full specialization, we
              # can fix all the tests without a large volume of edits by
              # simply specializing their workspaces, so for now I'm leaving
              # this in place as a somewhat sharp edge.
              if isinstance(term, LoadableTerm):
                  raise ValueError(
                      "Loadable workspace terms must be specialized to a "
                      "domain, but got generic term {}".format(term)
                  )
  
          elif term.domain != graph.domain:
              raise ValueError(
                  "Initial workspace term {} has domain {}. "
                  "Does not match pipeline domain {}".format(
                      term,
                      term.domain,
                      graph.domain,
                  )
              )
  
imports: from abc import ABCMeta, abstractmethod
  from functools import partial
  from six import iteritems, with_metaclass, viewkeys
  from numpy import array, arange
  from pandas import DataFrame, MultiIndex
  from toolz import groupby
  from zipline.lib.adjusted_array import ensure_adjusted_array, ensure_ndarray
  from zipline.errors import NoFurtherDataError
  from zipline.utils.input_validation import expect_types
  from zipline.utils.numpy_utils import as_column, repeat_first_axis, repeat_last_axis
  from zipline.utils.pandas_utils import explode
  from zipline.utils.string_formatting import bulleted_list
  from .domain import Domain, GENERIC
  from .graph import maybe_specialize
  from .hooks import DelegatingHooks
  from .term import AssetExists, InputDates, LoadableTerm
  from zipline.utils.date_utils import compute_date_range_chunks
  from zipline.utils.pandas_utils import categorical_df_concat
label_desc: Use image node_id 9 for calling the SimplePipelineEngine obj's underlying member method code with example usage: obj._validate_compute_chunk_params(graph, dates, sids, initial_workspace) without return types