code: def is_type(obj,
              type_,
              **kwargs):
      
      if not is_iterable(type_):
          type_ = [type_]
  
      return_value = False
      for check_for_type in type_:
          if isinstance(check_for_type, type):
              return_value = isinstance(obj, check_for_type)
          elif obj.__class__.__name__ == check_for_type:
              return_value = True
          else:
              return_value = _check_base_classes(obj.__class__.__bases__,
                                                 check_for_type)
  
          if return_value is True:
              break
  
      return return_value
docs: Indicate if ``obj`` is a type in ``type_``.
  
      .. hint::
  
        This checker is particularly useful when you want to evaluate whether
        ``obj`` is of a particular type, but importing that type directly to use
        in :func:`isinstance() <python:isinstance>` would cause a circular import
        error.
  
        To use this checker in that kind of situation, you can instead pass the
        *name* of the type you want to check as a string in ``type_``. The checker
        will evaluate it and see whether ``obj`` is of a type or inherits from a
        type whose name matches the string you passed.
  
      :param obj: The object whose type should be checked.
      :type obj: :class:`object <python:object>`
  
      :param type_: The type(s) to check against.
      :type type_: :class:`type <python:type>` / iterable of :class:`type <python:type>` /
        :class:`str <python:str>` with type name / iterable of :class:`str <python:str>`
        with type name
  
      :returns: ``True`` if ``obj`` is a type in ``type_``. Otherwise, ``False``.
      :rtype: :class:`bool <python:bool>`
  
      :raises SyntaxError: if ``kwargs`` contains duplicate keyword parameters or duplicates
        keyword parameters passed to the underlying validator