code: def expect_kinds(**named):
      
      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))
docs: 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.