code: def init(language, output_dir, clear_dir=True):
      """
      Entry point for the bindings module. It parses the command line arguments and verifies their
      correctness.
        :param language -- name of the target language (used to show the command-line description).
        :param output_dir -- folder where the bindings files will be generated. If the folder does
          not exist, it will be created. This folder is relative to ../src-gen/main/. The user may
          specify a different output dir through the commandline argument.
        :param clear_dir -- if True (default), the target folder will be cleared before any new
          files created in it.
      """
      if config["start_time"]:
          done()
      config["start_time"] = time.time()
      print("Generating %s bindings... " % language, end="")
      sys.stdout.flush()
  
      this_module_dir = os.path.dirname(os.path.realpath(__file__))
      default_output_dir = os.path.abspath(
          this_module_dir + "/../src-gen/main/" + output_dir
      )
  
      # Parse command-line options
      parser = argparse.ArgumentParser(
          description="""
          Generate %s REST API bindings (with docs) and write them to the filesystem.
          Must attach to a running H2O instance to query the interface."""
          % language,
      )
      parser.add_argument(
          "-v", "--verbose", help="Verbose output", action="store_true"
      )
      parser.add_argument(
          "--usecloud",
          metavar="IP:PORT",
          default="localhost:54321",
          help="Address of an H2O server (defaults to http://localhost:54321/)",
      )
      # Note: Output folder should be in build directory, however, Idea has problems to recognize them
      parser.add_argument(
          "--dest",
          metavar="DIR",
          default=default_output_dir,
          help="Destination directory for generated bindings",
      )
      args = parser.parse_args()
  
      # Post-process the options
      base_url = args.usecloud
      if not (
          base_url.startswith("http://")
          or base_url.startswith("https://")
      ):
          base_url = "http://" + base_url
      if not (base_url.endswith("/")):
          base_url += "/"
      config["baseurl"] = base_url
      config["verbose"] = args.verbose
      config["destdir"] = os.path.abspath(args.dest)
      vprint("\n\n")
  
      # Attempt to create the output directory
      try:
          vprint("Output directory = " + config["destdir"])
          os.makedirs(config["destdir"])
      except OSError as e:
          if e.errno != errno.EEXIST:
              print("Cannot create directory " + config["destdir"])
              print("Error %d: %s" % (e.errno, e.strerror))
              sys.exit(6)
  
      # Clear the content of the output directory. Note: deleting the directory and then recreating it may be
      # faster, but it creates side-effects that we want to avoid (i.e. clears permissions on the folder).
      if clear_dir:
          filepath = "?"
          try:
              vprint("Deleting contents of the output directory...")
              for filename in os.listdir(config["destdir"]):
                  filepath = os.path.join(config["destdir"], filename)
                  if os.path.isdir(filepath):
                      shutil.rmtree(filepath)
                  else:
                      os.unlink(filepath)
          except Exception as e:
              print("Unable to remove file %s: %r" % (filepath, e))
              sys.exit(9)
  
      # Check that the provided server is accessible; then print its status (if in --verbose mode).
      json = _request_or_exit("/3/About")
      l1 = max(len(e["name"]) for e in json["entries"])
      l2 = max(len(e["value"]) for e in json["entries"])
      ll = max(29 + len(config["baseurl"]), l1 + l2 + 2)
      vprint("-" * ll)
      vprint("Connected to an H2O instance " + config["baseurl"] + "\n")
      for e in json["entries"]:
          vprint(
              e["name"]
              + ":"
              + " " * (1 + l1 - len(e["name"]))
              + e["value"]
          )
      vprint("-" * ll)
  
imports: import argparse
  import atexit
  import codecs
  import errno
  import os
  import platform
  import pprint
  import re
  import requests
  import shutil
  import sys
  import textwrap
  import time
  from collections import defaultdict
label_desc: Use image node_id 3 for calling a global function with example usage: init(language, output_dir, clear_dir) without return types