code: def main(args=None, *, _wrap_timer=None):
      """Main program, used when run as a script.
  
      The optional 'args' argument specifies the command line to be parsed,
      defaulting to sys.argv[1:].
  
      The return value is an exit code to be passed to sys.exit(); it
      may be None to indicate success.
  
      When an exception happens during timing, a traceback is printed to
      stderr and the return value is 1.  Exceptions at other times
      (including the template compilation) are not caught.
  
      '_wrap_timer' is an internal interface used for unit testing.  If it
      is not None, it must be a callable that accepts a timer function
      and returns another timer function (used for unit testing).
      """
      if args is None:
          args = sys.argv[1:]
      import getopt
  
      try:
          opts, args = getopt.getopt(
              args,
              "n:u:s:r:tcpvh",
              [
                  "number=",
                  "setup=",
                  "repeat=",
                  "time",
                  "clock",
                  "process",
                  "verbose",
                  "unit=",
                  "help",
              ],
          )
      except getopt.error as err:
          print(err)
          print("use -h/--help for command line help")
          return 2
  
      timer = default_timer
      stmt = "\n".join(args) or "pass"
      number = 0  # auto-determine
      setup = []
      repeat = default_repeat
      verbose = 0
      time_unit = None
      units = {"nsec": 1e-9, "usec": 1e-6, "msec": 1e-3, "sec": 1.0}
      precision = 3
      for o, a in opts:
          if o in ("-n", "--number"):
              number = int(a)
          if o in ("-s", "--setup"):
              setup.append(a)
          if o in ("-u", "--unit"):
              if a in units:
                  time_unit = a
              else:
                  print(
                      "Unrecognized unit. Please select nsec, usec, msec, or sec.",
                      file=sys.stderr,
                  )
                  return 2
          if o in ("-r", "--repeat"):
              repeat = int(a)
              if repeat <= 0:
                  repeat = 1
          if o in ("-p", "--process"):
              timer = time.process_time
          if o in ("-v", "--verbose"):
              if verbose:
                  precision += 1
              verbose += 1
          if o in ("-h", "--help"):
              print(__doc__, end=" ")
              return 0
      setup = "\n".join(setup) or "pass"
  
      # Include the current directory, so that local imports work (sys.path
      # contains the directory of this script, rather than the current
      # directory)
      import os
  
      sys.path.insert(0, os.curdir)
      if _wrap_timer is not None:
          timer = _wrap_timer(timer)
  
      t = Timer(stmt, setup, timer)
      if number == 0:
          # determine number so that 0.2 <= total time < 2.0
          callback = None
          if verbose:
  
              def callback(number, time_taken):
                  msg = "{num} loop{s} -> {secs:.{prec}g} secs"
                  plural = number != 1
                  print(
                      msg.format(
                          num=number,
                          s="s" if plural else "",
                          secs=time_taken,
                          prec=precision,
                      )
                  )
  
          try:
              number, _ = t.autorange(callback)
          except:
              t.print_exc()
              return 1
  
          if verbose:
              print()
  
      try:
          raw_timings = t.repeat(repeat, number)
      except:
          t.print_exc()
          return 1
  
      def format_time(dt):
          unit = time_unit
  
          if unit is not None:
              scale = units[unit]
          else:
              scales = [(scale, unit) for unit, scale in units.items()]
              scales.sort(reverse=True)
              for scale, unit in scales:
                  if dt >= scale:
                      break
  
          return "%.*g %s" % (precision, dt / scale, unit)
  
      if verbose:
          print(
              "raw times: %s" % ", ".join(map(format_time, raw_timings))
          )
          print()
      timings = [dt / number for dt in raw_timings]
  
      best = min(timings)
      print(
          "%d loop%s, best of %d: %s per loop"
          % (
              number,
              "s" if number != 1 else "",
              repeat,
              format_time(best),
          )
      )
  
      best = min(timings)
      worst = max(timings)
      if worst >= best * 4:
          import warnings
  
          warnings.warn_explicit(
              "The test results are likely unreliable. "
              "The worst time (%s) was more than four times "
              "slower than the best time (%s)."
              % (format_time(worst), format_time(best)),
              UserWarning,
              "",
              0,
          )
      return None
  
file_path: catboost/contrib/tools/python3/src/Lib/timeit.py
imports: import gc
  import itertools
  import sys
  import time
label_desc: Use image node_id 4 for calling a global function with example usage: main(args) and returns: None, unknown, int, int, int, int, int