code: def expect_kinds(**named):
      """
      Preprocessing decorator that verifies inputs have expected dtype kinds.
  
      Examples
      --------
      >>> from numpy import int64, int32, float32
      >>> @expect_kinds(x='i')
      ... def foo(x):
      ...    return x
      ...
      >>> foo(int64(2))
      2
      >>> foo(int32(2))
      2
      >>> foo(float32(2))  # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
      Traceback (most recent call last):
         ...
      TypeError: ...foo() expected a numpy object of kind 'i' for argument 'x',
      but got 'f' instead.
      """
      for name, kind in iteritems(named):
          if not isinstance(kind, (str, tuple)):
              raise TypeError(
                  "expect_dtype_kinds() expected a string or tuple of strings"
                  " for argument {name!r}, but got {kind} instead.".format(
                      name=name,
                      kind=dtype,
                  )
              )
  
      @preprocess(
          kinds=call(lambda x: x if isinstance(x, tuple) else (x,))
      )
      def _expect_kind(kinds):
          """
          Factory for kind-checking functions that work the @preprocess
          decorator.
          """
  
          def error_message(func, argname, value):
              # If the bad value has a dtype, but it's wrong, show the dtype
              # kind.  Otherwise just show the value.
              try:
                  value_to_show = value.dtype.kind
              except AttributeError:
                  value_to_show = value
              return (
                  "{funcname}() expected a numpy object of kind {kinds} "
                  "for argument {argname!r}, but got {value!r} instead."
              ).format(
                  funcname=_qualified_name(func),
                  kinds=" or ".join(map(repr, kinds)),
                  argname=argname,
                  value=value_to_show,
              )
  
          def _actual_preprocessor(func, argname, argvalue):
              if (
                  getattrs(argvalue, ("dtype", "kind"), object())
                  not in kinds
              ):
                  raise TypeError(
                      error_message(func, argname, argvalue)
                  )
              return argvalue
  
          return _actual_preprocessor
  
      return preprocess(**valmap(_expect_kind, 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 8 for calling a global function with example usage: expect_kinds() and returns: preprocess, _actual_preprocessor, str, argvalue