class_docstr: A Term that should be computed from a tuple of inputs.
  
  This is the base class for :class:`zipline.pipeline.Factor`,
  :class:`zipline.pipeline.Filter`, and :class:`zipline.pipeline.Classifier`.
class_docstr_tok: ["A","Term","that","should","be","computed","from","a","tuple","of","inputs",".","This","is","the","base","class","for",":","class",":","`","zipline.pipeline.Factor","`",",",":","class",":","`","zipline.pipeline.Filter","`",",","and",":","class",":","`","zipline.pipeline.Classifier","`","."]
code: def _validate(self):
      super(ComputableTerm, self)._validate()
  
      # Check inputs.
      if self.inputs is NotSpecified:
          raise TermInputsNotSpecified(termname=type(self).__name__)
  
      if not isinstance(self.domain, Domain):
          raise TypeError(
              "Expected {}.domain to be an instance of Domain, "
              "but got {}.".format(
                  type(self).__name__, type(self.domain)
              )
          )
  
      # Check outputs.
      if self.outputs is NotSpecified:
          pass
      elif not self.outputs:
          raise TermOutputsEmpty(termname=type(self).__name__)
      else:
          # Raise an exception if there are any naming conflicts between the
          # term's output names and certain attributes.
          disallowed_names = [
              attr
              for attr in dir(ComputableTerm)
              if not attr.startswith("_")
          ]
  
          # The name 'compute' is an added special case that is disallowed.
          # Use insort to add it to the list in alphabetical order.
          insort(disallowed_names, "compute")
  
          for output in self.outputs:
              if output.startswith("_") or output in disallowed_names:
                  raise InvalidOutputName(
                      output_name=output,
                      termname=type(self).__name__,
                      disallowed_names=disallowed_names,
                  )
  
      if self.window_length is NotSpecified:
          raise WindowLengthNotSpecified(termname=type(self).__name__)
  
      if self.mask is NotSpecified:
          # This isn't user error, this is a bug in our code.
          raise AssertionError("{term} has no mask".format(term=self))
  
      if self.window_length > 1:
          for child in self.inputs:
              if not child.window_safe:
                  raise NonWindowSafeInput(parent=self, child=child)
  
imports: from abc import ABCMeta, abstractproperty, abstractmethod
  from bisect import insort
  from collections import Mapping
  from weakref import WeakValueDictionary
  from numpy import array, dtype, ndarray
  from six import with_metaclass
  from zipline.assets import Asset
  from zipline.errors import DTypeNotSpecified, InvalidOutputName, NonSliceableTerm, NonWindowSafeInput, NotDType, NonPipelineInputs, TermInputsNotSpecified, TermOutputsEmpty, UnsupportedDType, WindowLengthNotSpecified
  from zipline.lib.adjusted_array import can_represent_dtype
  from zipline.lib.labelarray import LabelArray
  from zipline.utils.input_validation import expect_types
  from zipline.utils.memoize import classlazyval, lazyval
  from zipline.utils.numpy_utils import bool_dtype, categorical_dtype, datetime64ns_dtype, default_missing_value_for_dtype, float64_dtype
  from zipline.utils.sharedoc import templated_docstring, PIPELINE_ALIAS_NAME_DOC, PIPELINE_DOWNSAMPLING_FREQUENCY_DOC
  from .domain import Domain, GENERIC, infer_domain
  from .downsample_helpers import expect_downsample_frequency
  from .sentinels import NotSpecified
label_desc: Use image node_id 4 for calling the ComputableTerm obj's underlying member method code with example usage: obj._validate() without return types