code: def expect_dtypes(__funcname=_qualified_name, **named):
      """
      Preprocessing decorator that verifies inputs have expected numpy dtypes.
  
      Examples
      --------
      >>> from numpy import dtype, arange, int8, float64
      >>> @expect_dtypes(x=dtype(int8))
      ... def foo(x, y):
      ...    return x, y
      ...
      >>> foo(arange(3, dtype=int8), 'foo')
      (array([0, 1, 2], dtype=int8), 'foo')
      >>> foo(arange(3, dtype=float64), 'foo')  # doctest: +NORMALIZE_WHITESPACE
      ...                                       # doctest: +ELLIPSIS
      Traceback (most recent call last):
         ...
      TypeError: ...foo() expected a value with dtype 'int8' for argument 'x',
      but got 'float64' instead.
      """
      for name, type_ in iteritems(named):
          if not isinstance(type_, (dtype, tuple)):
              raise TypeError(
                  "expect_dtypes() expected a numpy dtype or tuple of dtypes"
                  " for argument {name!r}, but got {dtype} instead.".format(
                      name=name,
                      dtype=dtype,
                  )
              )
  
      if isinstance(__funcname, str):
  
          def get_funcname(_):
              return __funcname
  
      else:
          get_funcname = __funcname
  
      @preprocess(
          dtypes=call(lambda x: x if isinstance(x, tuple) else (x,))
      )
      def _expect_dtype(dtypes):
          """
          Factory for dtype-checking functions that work with the @preprocess
          decorator.
          """
  
          def error_message(func, argname, value):
              # If the bad value has a dtype, but it's wrong, show the dtype
              # name.  Otherwise just show the value.
              try:
                  value_to_show = value.dtype.name
              except AttributeError:
                  value_to_show = value
              return (
                  "{funcname}() expected a value with dtype {dtype_str} "
                  "for argument {argname!r}, but got {value!r} instead."
              ).format(
                  funcname=get_funcname(func),
                  dtype_str=" or ".join(repr(d.name) for d in dtypes),
                  argname=argname,
                  value=value_to_show,
              )
  
          def _actual_preprocessor(func, argname, argvalue):
              if getattr(argvalue, "dtype", object()) not in dtypes:
                  raise TypeError(
                      error_message(func, argname, argvalue)
                  )
              return argvalue
  
          return _actual_preprocessor
  
      return preprocess(**valmap(_expect_dtype, 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 7 for calling a global function with example usage: expect_dtypes(__funcname) and returns: preprocess, _actual_preprocessor, __funcname, str, argvalue