code: def _get_field(cls, a_name, a_type):
      # Return a Field object for this field name and type.  ClassVars
      # and InitVars are also returned, but marked as such (see
      # f._field_type).
  
      # If the default value isn't derived from Field, then it's only a
      # normal default value.  Convert it to a Field().
      default = getattr(cls, a_name, MISSING)
      if isinstance(default, Field):
          f = default
      else:
          if isinstance(default, types.MemberDescriptorType):
              # This is a field in __slots__, so it has no default value.
              default = MISSING
          f = field(default=default)
  
      # Only at this point do we know the name and the type.  Set them.
      f.name = a_name
      f.type = a_type
  
      # Assume it's a normal field until proven otherwise.  We're next
      # going to decide if it's a ClassVar or InitVar, everything else
      # is just a normal field.
      f._field_type = _FIELD
  
      # In addition to checking for actual types here, also check for
      # string annotations.  get_type_hints() won't always work for us
      # (see https://github.com/python/typing/issues/508 for example),
      # plus it's expensive and would require an eval for every stirng
      # annotation.  So, make a best effort to see if this is a ClassVar
      # or InitVar using regex's and checking that the thing referenced
      # is actually of the correct type.
  
      # For the complete discussion, see https://bugs.python.org/issue33453
  
      # If typing has not been imported, then it's impossible for any
      # annotation to be a ClassVar.  So, only look for ClassVar if
      # typing has been imported by any module (not necessarily cls's
      # module).
      typing = sys.modules.get("typing")
      if typing:
          if _is_classvar(a_type, typing) or (
              isinstance(f.type, str)
              and _is_type(
                  f.type, cls, typing, typing.ClassVar, _is_classvar
              )
          ):
              f._field_type = _FIELD_CLASSVAR
  
      # If the type is InitVar, or if it's a matching string annotation,
      # then it's an InitVar.
      if f._field_type is _FIELD:
          # The module we're checking against is the module we're
          # currently in (dataclasses.py).
          dataclasses = sys.modules[__name__]
          if _is_initvar(a_type, dataclasses) or (
              isinstance(f.type, str)
              and _is_type(
                  f.type,
                  cls,
                  dataclasses,
                  dataclasses.InitVar,
                  _is_initvar,
              )
          ):
              f._field_type = _FIELD_INITVAR
  
      # Validations for individual fields.  This is delayed until now,
      # instead of in the Field() constructor, since only here do we
      # know the field name, which allows for better error reporting.
  
      # Special restrictions for ClassVar and InitVar.
      if f._field_type in (_FIELD_CLASSVAR, _FIELD_INITVAR):
          if f.default_factory is not MISSING:
              raise TypeError(
                  f"field {f.name} cannot have a " "default factory"
              )
          # Should I check for other field settings? default_factory
          # seems the most serious to check for.  Maybe add others.  For
          # example, how about init=False (or really,
          # init=<not-the-default-init-value>)?  It makes no sense for
          # ClassVar and InitVar to specify init=<anything>.
  
      # For real fields, disallow mutable defaults for known types.
      if f._field_type is _FIELD and isinstance(
          f.default, (list, dict, set)
      ):
          raise ValueError(
              f"mutable default {type(f.default)} for field "
              f"{f.name} is not allowed: use default_factory"
          )
  
      return f
  
imports: import re
  import sys
  import copy
  import types
  import inspect
  import keyword
label_desc: Use image node_id 15 for calling a global function with example usage: _get_field(cls, a_name, a_type) and returns: f