code: def copytree3(
      src,
      dst,
      symlinks=False,
      ignore=None,
      copy_function=shutil.copy2,
      ignore_dangling_symlinks=False,
      dirs_exist_ok=False,
  ):
      """Recursively copy a directory tree.
  
      The copytree3 is a port of shutil.copytree function from python-3.2.
      It has additional useful parameters and may be helpful while we are
      on python-2.x. It has to be removed as soon as we have moved to
      python-3.2 or higher.
  
      The destination directory must not already exist.
      If exception(s) occur, an Error is raised with a list of reasons.
  
      If the optional symlinks flag is true, symbolic links in the
      source tree result in symbolic links in the destination tree; if
      it is false, the contents of the files pointed to by symbolic
      links are copied. If the file pointed by the symlink doesn't
      exist, an exception will be added in the list of errors raised in
      an Error exception at the end of the copy process.
  
      You can set the optional ignore_dangling_symlinks flag to true if you
      want to silence this exception. Notice that this has no effect on
      platforms that don't support os.symlink.
  
      The optional ignore argument is a callable. If given, it
      is called with the `src` parameter, which is the directory
      being visited by copytree3(), and `names` which is the list of
      `src` contents, as returned by os.listdir():
  
          callable(src, names) -> ignored_names
  
      Since copytree3() is called recursively, the callable will be
      called once for each directory that is copied. It returns a
      list of names relative to the `src` directory that should
      not be copied.
  
      The optional copy_function argument is a callable that will be used
      to copy each file. It will be called with the source path and the
      destination path as arguments. By default, copy2() is used, but any
      function that supports the same signature (like copy()) can be used.
  
      """
      names = os.listdir(src)
      if ignore is not None:
          ignored_names = ignore(src, names)
      else:
          ignored_names = set()
  
      if not (dirs_exist_ok and os.path.isdir(dst)):
          os.makedirs(dst)
  
      errors = []
      for name in names:
          if name in ignored_names:
              continue
          srcname = os.path.join(src, name)
          dstname = os.path.join(dst, name)
          try:
              if os.path.islink(srcname):
                  linkto = os.readlink(srcname)
                  if symlinks:
                      # We can't just leave it to `copy_function` because legacy
                      # code with a custom `copy_function` may rely on copytree3
                      # doing the right thing.
                      os.symlink(linkto, dstname)
                  else:
                      # ignore dangling symlink if the flag is on
                      if (
                          not os.path.exists(linkto)
                          and ignore_dangling_symlinks
                      ):
                          continue
                      # otherwise let the copy occurs. copy2 will raise an error
                      copy_function(srcname, dstname)
              elif os.path.isdir(srcname):
                  copytree3(
                      srcname,
                      dstname,
                      symlinks,
                      ignore,
                      copy_function,
                      dirs_exist_ok=dirs_exist_ok,
                  )
              else:
                  # Will raise a SpecialFileError for unsupported file types
                  copy_function(srcname, dstname)
          # catch the Error from the recursive copytree3 so that we can
          # continue with other files
          except shutil.Error as err:
              errors.extend(err.args[0])
          except EnvironmentError as why:
              errors.append((srcname, dstname, str(why)))
      try:
          shutil.copystat(src, dst)
      except OSError as why:
          if WindowsError is not None and isinstance(why, WindowsError):
              # Copying file access times may fail on Windows
              pass
          else:
              errors.extend((src, dst, str(why)))
      if errors:
          raise shutil.Error(errors)
  
imports: import codecs
  import errno
  import logging
  import os
  import random
  import shutil
  import six
  import stat
  import sys
  import library.python.func
  import library.python.strings
  import library.python.windows
label_desc: Use image node_id 27 for calling a global function with example usage: copytree3(src, dst, symlinks, ignore, copy_function, ignore_dangling_symlinks, dirs_exist_ok) without return types