code: def check_imports(
      no_check=(), extra=(), skip_func=None, py_main=None
  ):
      """
      tests all bundled modules are importable
      just add
      "PEERDIR(library/python/import_test)" to your CMakeLists.txt and
      "from import_test import test_imports" to your python test source file.
      """
  
      if not isinstance(b"", str):
  
          def str_(s):
              return s.decode("UTF-8")
  
      else:
  
          def str_(s):
              return s
  
      exceptions = list(no_check)
      for key, _ in __res.iter_keys(b"py/no_check_imports/"):
          exceptions += str_(__res.find(key)).split()
      if exceptions:
          exceptions.sort()
          print("NO_CHECK_IMPORTS", " ".join(exceptions))
  
      # all test modules get imported when tests are run
      exceptions.append("__tests__.*")
  
      patterns = [
          re.escape(s).replace(r"\*", r".*") for s in exceptions
      ]
      rx = re.compile("^({})$".format("|".join(patterns)))
  
      failed = []
      import_times = {}
  
      def norm(s):
          return s[:-9] if s.endswith(".__init__") else s
  
      modules = sys.extra_modules | set(extra)
      modules = sorted(modules, key=norm)
      if py_main:
          modules = [py_main] + modules
  
      for module in modules:
          if module not in extra and (
              rx.search(module) or skip_func and skip_func(module)
          ):
              print("SKIP", module)
              continue
  
          name = module.rsplit(".", 1)[-1]
          if (
              name == "__main__"
              and "if __name__ ==" not in importer.get_source(module)
          ):
              print(
                  "SKIP",
                  module,
                  """without "if __name__ == '__main__'" check""",
              )
              continue
  
          def print_backtrace_marked(e):
              tb_exc = traceback.format_exception(*e)
              for item in tb_exc:
                  for line in item.splitlines():
                      print("FAIL:", line, file=sys.stderr)
  
          try:
              print("TRY", module)
              # XXX waiting for py3 to use print(..., flush=True)
              sys.stdout.flush()
  
              s = time.time()
              with warnings.catch_warnings():
                  warnings.filterwarnings(
                      action="ignore", category=DeprecationWarning
                  )
                  if module == "__main__":
                      importer.load_module("__main__", "__main__py")
                  elif module.endswith(".__init__"):
                      __import__(module[: -len(".__init__")])
                  else:
                      __import__(module)
  
              delay = time.time() - s
              import_times[str(module)] = delay
              print("OK ", module, "{:.3f}s".format(delay))
  
          except Exception as e:
              print("FAIL:", module, e, file=sys.stderr)
              print_backtrace_marked(sys.exc_info())
              failed.append("{}: {}".format(module, e))
  
          except BaseException:
              e = sys.exc_info()
              print("FAIL:", module, e, file=sys.stderr)
              print_backtrace_marked(e)
              failed.append("{}: {}".format(module, e))
              raise
  
      print("Slowest imports:")
      for m, t in sorted(
          import_times.items(), key=lambda x: x[1], reverse=True
      )[:30]:
          print("  ", "{:.3f}s".format(t), m)
  
      if failed:
          raise ImportError(
              "modules not imported:\n" + "\n".join(failed)
          )
  
file_path: catboost/library/python/testing/import_test/import_test.py
imports: from __future__ import print_function
  import os
  import re
  import sys
  import time
  import signal
  import traceback
  import warnings
  import __res
  from __res import importer
label_desc: Use image node_id 2 for calling a global function with example usage: check_imports(no_check, extra, skip_func, py_main) and returns: unknown, s, s