code: def fileConfig(
      fname, defaults=None, disable_existing_loggers=True, encoding=None
  ):
      """
      Read the logging configuration from a ConfigParser-format file.
  
      This can be called several times from an application, allowing an end user
      the ability to select from various pre-canned configurations (if the
      developer provides a mechanism to present the choices and load the chosen
      configuration).
      """
      import configparser
  
      if isinstance(fname, str):
          if not os.path.exists(fname):
              raise FileNotFoundError(f"{fname} doesn't exist")
          elif not os.path.getsize(fname):
              raise RuntimeError(f"{fname} is an empty file")
  
      if isinstance(fname, configparser.RawConfigParser):
          cp = fname
      else:
          try:
              cp = configparser.ConfigParser(defaults)
              if hasattr(fname, "readline"):
                  cp.read_file(fname)
              else:
                  encoding = io.text_encoding(encoding)
                  cp.read(fname, encoding=encoding)
          except configparser.ParsingError as e:
              raise RuntimeError(f"{fname} is invalid: {e}")
  
      formatters = _create_formatters(cp)
  
      # critical section
      logging._acquireLock()
      try:
          _clearExistingHandlers()
  
          # Handlers add themselves to logging._handlers
          handlers = _install_handlers(cp, formatters)
          _install_loggers(cp, handlers, disable_existing_loggers)
      finally:
          logging._releaseLock()
  
imports: import errno
  import io
  import logging
  import logging.handlers
  import os
  import queue
  import re
  import struct
  import threading
  import traceback
  from socketserver import ThreadingTCPServer, StreamRequestHandler
label_desc: Use image node_id 1 for calling a global function with example usage: fileConfig(fname, defaults, disable_existing_loggers, encoding) without return types