code: def _is_type(annotation, cls, a_module, a_type, is_type_predicate):
      # Given a type annotation string, does it refer to a_type in
      # a_module?  For example, when checking that annotation denotes a
      # ClassVar, then a_module is typing, and a_type is
      # typing.ClassVar.
  
      # It's possible to look up a_module given a_type, but it involves
      # looking in sys.modules (again!), and seems like a waste since
      # the caller already knows a_module.
  
      # - annotation is a string type annotation
      # - cls is the class that this annotation was found in
      # - a_module is the module we want to match
      # - a_type is the type in that module we want to match
      # - is_type_predicate is a function called with (obj, a_module)
      #   that determines if obj is of the desired type.
  
      # Since this test does not do a local namespace lookup (and
      # instead only a module (global) lookup), there are some things it
      # gets wrong.
  
      # With string annotations, cv0 will be detected as a ClassVar:
      #   CV = ClassVar
      #   @dataclass
      #   class C0:
      #     cv0: CV
  
      # But in this example cv1 will not be detected as a ClassVar:
      #   @dataclass
      #   class C1:
      #     CV = ClassVar
      #     cv1: CV
  
      # In C1, the code in this function (_is_type) will look up "CV" in
      # the module and not find it, so it will not consider cv1 as a
      # ClassVar.  This is a fairly obscure corner case, and the best
      # way to fix it would be to eval() the string "CV" with the
      # correct global and local namespaces.  However that would involve
      # a eval() penalty for every single field of every dataclass
      # that's defined.  It was judged not worth it.
  
      match = _MODULE_IDENTIFIER_RE.match(annotation)
      if match:
          ns = None
          module_name = match.group(1)
          if not module_name:
              # No module name, assume the class's module did
              # "from dataclasses import InitVar".
              ns = sys.modules.get(cls.__module__).__dict__
          else:
              # Look up module_name in the class's module.
              module = sys.modules.get(cls.__module__)
              if (
                  module
                  and module.__dict__.get(module_name) is a_module
              ):
                  ns = sys.modules.get(a_type.__module__).__dict__
          if ns and is_type_predicate(ns.get(match.group(2)), a_module):
              return True
      return False
  
imports: import re
  import sys
  import copy
  import types
  import inspect
  import keyword
  import functools
  import itertools
  import abc
  import _thread
  from types import FunctionType, GenericAlias
label_desc: Use image node_id 17 for calling a global function with example usage: _is_type(annotation, cls, a_module, a_type, is_type_predicate) and returns: False, True