code: def copytree(
      src,
      dst,
      symlinks=False,
      ignore=None,
      copy_function=copy2,
      ignore_dangling_symlinks=False,
      dirs_exist_ok=False,
  ):
      """Recursively copy a directory tree and return the destination directory.
  
      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 copytree(), and `names` which is the list of
      `src` contents, as returned by os.listdir():
  
          callable(src, names) -> ignored_names
  
      Since copytree() 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.
  
      If dirs_exist_ok is false (the default) and `dst` already exists, a
      `FileExistsError` is raised. If `dirs_exist_ok` is true, the copying
      operation will continue if it encounters existing directories, and files
      within the `dst` tree will be overwritten by corresponding files from the
      `src` tree.
      """
      sys.audit("shutil.copytree", src, dst)
      with os.scandir(src) as itr:
          entries = list(itr)
      return _copytree(
          entries=entries,
          src=src,
          dst=dst,
          symlinks=symlinks,
          ignore=ignore,
          copy_function=copy_function,
          ignore_dangling_symlinks=ignore_dangling_symlinks,
          dirs_exist_ok=dirs_exist_ok,
      )
  
imports: import os
  import sys
  import stat
  import fnmatch
  import collections
  import errno
label_desc: Use image node_id 15 for calling a global function with example usage: copytree(src, dst, symlinks, ignore, copy_function, ignore_dangling_symlinks, dirs_exist_ok) and returns: _copytree