code: def expect_types(__funcname=_qualified_name, **named):
      """
      Preprocessing decorator that verifies inputs have expected types.
  
      Examples
      --------
      >>> @expect_types(x=int, y=str)
      ... def foo(x, y):
      ...    return x, y
      ...
      >>> foo(2, '3')
      (2, '3')
      >>> foo(2.0, '3')  # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
      Traceback (most recent call last):
         ...
      TypeError: ...foo() expected a value of type int for argument 'x',
      but got float instead.
  
      Notes
      -----
      A special argument, __funcname, can be provided as a string to override the
      function name shown in error messages.  This is most often used on __init__
      or __new__ methods to make errors refer to the class name instead of the
      function name.
      """
      for name, type_ in iteritems(named):
          if not isinstance(type_, (type, tuple)):
              raise TypeError(
                  "expect_types() expected a type or tuple of types for "
                  "argument '{name}', but got {type_} instead.".format(
                      name=name,
                      type_=type_,
                  )
              )
  
      def _expect_type(type_):
          # Slightly different messages for type and tuple of types.
          _template = (
              "%(funcname)s() expected a value of type {type_or_types} "
              "for argument '%(argname)s', but got %(actual)s instead."
          )
          if isinstance(type_, tuple):
              template = _template.format(
                  type_or_types=" or ".join(map(_qualified_name, type_))
              )
          else:
              template = _template.format(
                  type_or_types=_qualified_name(type_)
              )
  
          return make_check(
              exc_type=TypeError,
              template=template,
              pred=lambda v: not isinstance(v, type_),
              actual=compose(_qualified_name, type),
              funcname=__funcname,
          )
  
      return preprocess(**valmap(_expect_type, named))
  
imports: from datetime import tzinfo
  from functools import partial
  from operator import attrgetter
  from numpy import dtype
  import pandas
  from pytz import timezone
  from six import iteritems, string_types, PY3
  from toolz import valmap, complement, compose
  import toolz.curried.operator
  from zipline.utils.compat import wraps
  from zipline.utils.functional import getattrs
  from zipline.utils.preprocess import call, preprocess
label_desc: Use image node_id 9 for calling a global function with example usage: expect_types(__funcname) and returns: preprocess, make_check