code: def _field_init(f, frozen, globals, self_name, slots):
      # Return the text of the line in the body of __init__ that will
      # initialize this field.
  
      default_name = f"__dataclass_dflt_{f.name}__"
      if f.default_factory is not MISSING:
          if f.init:
              # This field has a default factory.  If a parameter is
              # given, use it.  If not, call the factory.
              globals[default_name] = f.default_factory
              value = (
                  f"{default_name}() "
                  f"if {f.name} is __dataclass_HAS_DEFAULT_FACTORY__ "
                  f"else {f.name}"
              )
          else:
              # This is a field that's not in the __init__ params, but
              # has a default factory function.  It needs to be
              # initialized here by calling the factory function,
              # because there's no other way to initialize it.
  
              # For a field initialized with a default=defaultvalue, the
              # class dict just has the default value
              # (cls.fieldname=defaultvalue).  But that won't work for a
              # default factory, the factory must be called in __init__
              # and we must assign that to self.fieldname.  We can't
              # fall back to the class dict's value, both because it's
              # not set, and because it might be different per-class
              # (which, after all, is why we have a factory function!).
  
              globals[default_name] = f.default_factory
              value = f"{default_name}()"
      else:
          # No default factory.
          if f.init:
              if f.default is MISSING:
                  # There's no default, just do an assignment.
                  value = f.name
              elif f.default is not MISSING:
                  globals[default_name] = f.default
                  value = f.name
          else:
              # If the class has slots, then initialize this field.
              if slots and f.default is not MISSING:
                  globals[default_name] = f.default
                  value = default_name
              else:
                  # This field does not need initialization: reading from it will
                  # just use the class attribute that contains the default.
                  # Signify that to the caller by returning None.
                  return None
  
      # Only test this now, so that we can create variables for the
      # default.  However, return None to signify that we're not going
      # to actually do the assignment statement for InitVars.
      if f._field_type is _FIELD_INITVAR:
          return None
  
      # Now, actually generate the field assignment.
      return _field_assign(frozen, f.name, value, self_name)
  
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 7 for calling a global function with example usage: _field_init(f, frozen, globals, _name, slots) and returns: _field_assign, None, None