# `shutil` — Operaciones de archivos de alto nivel

Código fuente: Lib/shutil.py

El módulo `shutil` ofrece varias operaciones de alto nivel en archivos y colecciones de archivos. En particular, provee funciones que dan soporte a la copia y remoción de archivos. Para operaciones en archivos individuales, véase también el módulo `os`.

Advertencia

Incluso las funciones de copia de archivos de nivel superior (`shutil.copy()`, `shutil.copy2()`) no pueden copiar todos los metadatos del archivo.

En las plataformas POSIX, esto significa que tanto el propietario como el grupo del archivo se pierden, al igual que las ACLs (access control lists o lista de control de acceso). En Mac OS, la bifurcación (fork) de recursos y de otros metadatos no se utilizan. Esto quiere decir que los recursos se perderán y que el tipo de archivo y los códigos de creador no serán correctos. En Windows, los propietarios de archivos, las ACLs y secuencias de datos alternativas no se copian.

## Operaciones de directorios y archivos

`shutil.``copyfileobj`(fsrc, fdst[, length])

  Copia los contenidos del objeto de tipo archivo fsrc en el objeto fdst. El valor entero length, si está indicado, es el tamaño del búfer. En particular, un valor length negativo significa copiar los datos sin recorrer los datos de origen en fragmentos; los datos se leen en fragmentos en forma predeterminada para evitar el consumo de memoria incontrolado. Nótese que si la posición actual del archivo del objeto fsrc es distinto de cero, solo se copiarán el contenido desde la posición actual del archivo hasta el final.

`shutil.``copyfile`(src, dst, *, follow_symlinks=True)

  Copia los contenidos (sin metadatos) del archivo src en un archivo denominado dst y retorna dst de la manera más eficaz posible. src y dst son objetos de tipo ruta o nombres de ruta dados como cadenas de caracteres.

  dst debe ser el nombre completo del archivo destino; véase `shutil.copy()` para una copia que acepta una ruta de directorio destino. Si src y dst refieren al mismo archivo, se lanza `SameFileError`.

  El local de destino debe tener permisos de escritura; de lo contrario, se genera una excepción `OSError`. Si dst ya existe, se reemplazará. Los archivos especiales, como los dispositivos de caracteres o de bloques y pipes, no se pueden copiar con esta función.

  Si follow_symlinks es falso y src es un enlace simbólico, un enlace simbólico nuevo se creará en lugar de copiar el archivo al que src apunta.

  Se genera un evento de auditoría `shutil.copyfile` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Solía generarse `IOError` en lugar de `OSError`. Se añadió el argumento follow_symlinks. Ahora retorna dst.

  Distinto en la versión 3.4: Genera `SameFileError` en lugar de `Error`. Dado que la primera es una subclase de la segunda, el cambio es compatible con versiones anteriores.

  Distinto en la versión 3.8: Los llamadas al sistema de copia rápida específicos de la plataforma se pueden usar internamente para copiar el archivo de manera más eficiente. Véase la sección Operaciones de copia eficientes dependientes de la plataforma.

exception `shutil.``SameFileError`

  Esta excepción se genera si el origen y destino en `copyfile()` son el mismo archivo.

  Nuevo en la versión 3.4.

`shutil.``copymode`(src, dst, *, follow_symlinks=True)

  Copia los bits de permiso de src a dst. Los contenidos, el propietario y el grupo no se ven afectados. src y dst son objetos tipo ruta o nombres de ruta dados como cadenas de caracteres. Si follow_symlinks es falso, y tanto src como dst son enlaces simbólicos, `copymode()` intentará modificar el modo de dst (y no el archivo al que apunta). Esta funcionalidad no está disponible en todas las plataformas; véase `copystat()` para mayor información. Si `copymode()` no puede modificar los enlaces simbólicos de la plataforma local y se le solicita hacerlo, no hará nada y retornará.

  Genera un evento de auditoría `shutil.copymode` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Se añadió el argumento follow_symlinks.

`shutil.``copystat`(src, dst, *, follow_symlinks=True)

  Copia los bits de permiso, la última hora de acceso, la última hora de modificación y las flags desde src a dst. En Linux, `copystat()` también copia los «atributos extendidos» siempre que sea posible. Los contenidos, el propietario y el grupo del archivo no se ven afectados. src y dst son objetos de tipo a ruta o nombres de ruta dados como cadenas de caracteres.

  Si follow_symlinks es falso, y src y dst hacen referencia los enlaces simbólicos, `copystat()` funcionará con los enlaces simbólicos en lugar de en los archivos a los que estos se refieren: leer la información del enlace simbólico src y escribirla en el enlace simbólico dst.

  Nota

  No todas las plataformas proporcionan la capacidad de examinar y modificar enlaces simbólicos. Python puede indicarte qué funcionalidad está disponible localmente.

  - Si `os.chmod in os.supports_follow_symlinks` es `True`, `copystat()` puede modificar los bits de permiso de un enlace simbólico.

  - Si `os.utime in os.supports_follow_symlinks` es `True`, `copystat()` puede modificar el último acceso y las veces que un enlace simbólico fue modificado.

  - Si `os.chflags in os.supports_follow_symlinks` es `True`, `copystat()` puede modificar las flags de un enlace simbólico. (`os.chflags` no está disponible en todas las plataformas.)

  En plataformas donde parte o toda esta funcionalidad no está disponible, cuando se le pida modificar un enlace simbólico, `copystat()` copiará todo lo que pueda. `copystat()` nunca retorna un error.

  Véase `os.supports_follow_symlinks` para más información.

  Genera un evento de auditoría `shutil.copystat` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Se ha añadido el argumento follow_symlinks y el soporte para atributos extendidos de Linux.

`shutil.``copy`(src, dst, *, follow_symlinks=True)

  Copies the file src to the file or directory dst. src and dst should be path-like objects or strings. If dst specifies a directory, the file will be copied into dst using the base filename from src. Returns the path to the newly created file.

  Si follow_symlinks es falso, y src es un enlace simbólico, dst se creará como enlace simbólico. Si follow_symlinks es verdadero y src es un enlace simbólico, dst será una copia del archivo al que src hace referencia.

  `copy()` copia los datos del archivo y el modo de permiso del archivo (véase `os.chmod()`). Otros metadatos, como los tiempos de creación y modificación de archivos, no se preservan. Para preservar todos los metadatos del archivo, usa `copy2()` en su lugar.

  Se genera un evento de auditoría `shutil.copyfile` con argumentos `src`, `dst`.

  Genera un evento de auditoría `shutil.copymode` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Se ha añadido el argumento follow_symlinks. Ahora retorna la ruta de acceso al archivo recién creado.

  Distinto en la versión 3.8: Los llamadas al sistema de copia rápida específicos de la plataforma se pueden usar internamente para copiar el archivo de manera más eficiente. Véase la sección Operaciones de copia eficientes dependientes de la plataforma.

`shutil.``copy2`(src, dst, *, follow_symlinks=True)

  Idéntico a `copy()` , excepto que `copy2()` también intenta conservar los metadatos del archivo.

  Cuando follow_symlinks es falso, y src es un enlace simbólico, `copy2()` intenta copiar todos los metadatos del enlace simbólico src en el enlace simbólico dst recién creado. Sin embargo, esta funcionalidad no está disponible en todas las plataformas. En las plataformas donde parte o toda esta funcionalidad no está disponible, `copy2()` conservará todos los metadatos que pueda; `copy2()` nunca genera una excepción porque no puede conservar los metadatos del archivo.

  `copy2()` usa `copystat()` para copiar todos los metadatos del archivo. Véase `copystat()` para más información sobre la compatibilidad con la plataforma para modificar los metadatos del enlace simbólico.

  Se genera un evento de auditoría `shutil.copyfile` con argumentos `src`, `dst`.

  Genera un evento de auditoría `shutil.copystat` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Añadido el argumento follow_symlinks, intenta copiar también los atributos del sistema de archivos extendidos (actualmente solo en Linux). Ahora retorna la ruta de acceso al archivo recién creado.

  Distinto en la versión 3.8: Los llamadas al sistema de copia rápida específicos de la plataforma se pueden usar internamente para copiar el archivo de manera más eficiente. Véase la sección Operaciones de copia eficientes dependientes de la plataforma.

`shutil.``ignore_patterns`(*patterns)

  Esta función de fábrica crea una función que puede ser usada como un invocable para el argumento ignore de `copytree()`, ignorando los archivos y directorios que coinciden con uno de los patrones patterns de estilo glob provistos. Véase el ejemplo siguiente.

`shutil.``copytree`(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False)

  Copia recursivamente un directorio tree entero con raíz en src en un directorio llamado dst y retorna un directorio destino. dirs_exist_ok dicta si debe generar una excepción en caso de que dst o cualquier directorio principal que falte ya exista.

  Los permisos y los tiempos de directorios son copiados con `copystat()`; los archivos individuales son copiados usando `copy2()`.

  Si symlinks es verdadero, los enlaces simbólicos en el árbol de origen son representados como enlaces simbólicos en el árbol nuevo y los metadatos de los enlaces originales serán copiados mientras la plataforma lo permita; si es falso o se omite, los contenidos y los metadatos de los archivos vinculados se copiarán en el árbol nuevo.

  Cuando symlinks es falso y el archivo al que apunta no exista, se agrega una excepción a la lista de errores generados en una excepción `Error` al final del proceso de copia. Puedes establecer la marca opcional ignore_dangling_symlinks en verdadero si deseas silenciar esa excepción. Ten en cuenta que esta opción no tiene efecto en plataformas que no admiten `os.symlink()`.

  Si se proporciona ignore, debe ser un invocable que recibirá como argumentos el directorio visitado por `copytree()` y una lista de sus contenidos, tal como los retorna `os.listdir()`. Ya que `copytree()` se invoca recursivamente, el invocable ignore se llamará una vez por cada directorio que se copia. El invocable debe retornar una secuencia de directorio y de nombres de archivo en relación con el directorio actual (es decir, un subconjunto de los elementos en su segundo argumento); estos nombres serán ignorados en el proceso de copia. `ignore_patterns()` se pueden usar para crear un invocable que ignora los nombres basados en patrones de estilo gob.

  Si ocurren excepciones, se genera, un `Error` con una lista de razones.

  Si copy_function está dado, debe ser un invocable que se usará para copiar cada archivo. Se le invocará con la ruta de origen y la ruta de destino como argumentos. Por defecto, se usa `copy2()`, pero se puede usar cualquier función que admita la misma (como `copy()`).

  Se genera un evento de auditoría `shutil.copytree` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Copia los metadatos cuando symlinks es falso. Ahora retorna dst.

  Distinto en la versión 3.2: Se añadió el argumento copy_function para poder proporcionar una función de copia personalizada. Se añadió el argumento ignore_dangling_symlinks a los errores de enlaces colgantes silenciosos cuando symlinks es falso.

  Distinto en la versión 3.8: Los llamadas al sistema de copia rápida específicos de la plataforma se pueden usar internamente para copiar el archivo de manera más eficiente. Véase la sección Operaciones de copia eficientes dependientes de la plataforma.

  Nuevo en la versión 3.8: El parámetro dirs_exist_ok.

`shutil.``rmtree`(path, ignore_errors=False, onerror=None)

  Elimina un árbol de directorios entero; path debe apuntar a un directorio (pero no a un enlace simbólico a un directorio). Si ignore_errors es verdadero, se eliminarán los errores que resulten de eliminaciones fallidas; si es falso u omitido, estos errores se controlan invocando un controlador especificado por onerror o, si este es omitido, se genera una excepción.

  Nota

  En plataformas que admiten las funciones basadas en descriptores de archivo necesarias, una versión resistente de `rmtree()` al ataque de enlace simbólico se usa por defecto. En otras plataformas, la implementación `rmtree()` es susceptible a un ataque de enlace simbólico; dados el tiempo y las circunstancias adecuados, los atacantes pueden manipular los enlaces simbólicos en el sistema de archivos para eliminar archivos a los que no podrían acceder de otra manera. Las aplicaciones pueden usar el atributo de función `rmtree.avoids_symlink_attacks` para determinar qué caso aplica.

  Si se onerror está dado, debe ser un invocable que acepte tres parámetros: function, path, y excinfo.

  El primer parámetro, function, es la función que generó la excepción; depende de la plataforma y de la implementación. El segundo parámetro, path, será el nombre de ruta pasado a function. El tercer parámetro, excinfo, será la información de la excepción retornada por `sys.exc_info()`. Las excepciones generadas por onerror no serán tomadas.

  Genera un evento de auditoría `shutil.rmtree` con argumento `path`.

  Distinto en la versión 3.3: Se añadió una versión resistente a los ataques de enlaces simbólicos que se usan automáticamente si la plataforma admite funciones pasadas en descriptores de archivo.

  Distinto en la versión 3.8: En Windows, ya no eliminará los contenidos de un cruce de directorios antes de quitar el cruce.

  `rmtree.``avoids_symlink_attacks`

    Indica si la plataforma actual y la implementación proporciona una versión de `rmtree()` resistente al ataque de enlace simbólico. Actualmente, esto solo sucede para plataformas que admitan funciones de acceso a directorios basadas en descriptores de archivo.

    Nuevo en la versión 3.3.

`shutil.``move`(src, dst, copy_function=copy2)

  Mueve de forma recursiva un archivo o directorio (src) a otra ubicación (dst) y retorna el destino.

  Si el destino es un directorio existente, entonces src se mueve dentro de ese directorio. Si el destino existe pero no es un directorio, puede sobrescribirse dependiendo de la semántica `os.rename()`.

  Si el destino está en el sistema de archivos actual, entonces se usa `os.rename()`. De lo contrario, src se copia en dst usando copy_function y luego se elimina. En el caso de los enlaces simbólicos, se creará un enlace simbólico nuevo que apunta al destino de *src en o como dst y será eliminado.

  If copy_function is given, it must be a callable that takes two arguments src and dst, and will be used to copy src to dst if `os.rename()` cannot be used. If the source is a directory, `copytree()` is called, passing it the `copy_function()`. The default copy_function is `copy2()`. Using `copy()` as the copy_function allows the move to succeed when it is not possible to also copy the metadata, at the expense of not copying any of the metadata.

  Genera un evento de auditoría `shutil.move` con argumentos `src`, `dst`.

  Distinto en la versión 3.3: Se añadió el manejo explícito de enlaces simbólicos para sistemas de archivos extranjeros, de manera que se adapta al comportamiento del mv del GNU. Ahora retorna dst.

  Distinto en la versión 3.5: Se agregó el argumento de keyword copy_function.

  Distinto en la versión 3.8: Los llamadas al sistema de copia rápida específicos de la plataforma se pueden usar internamente para copiar el archivo de manera más eficiente. Véase la sección Operaciones de copia eficientes dependientes de la plataforma.

`shutil.``disk_usage`(path)

  Retorna las estadísticas de uso de disco sobre la ruta de acceso dada como un named tuple con los atributos total, used y free, que son las cantidades del espacio total, el usado y el libre, en bytes. path puede ser un archivo o un directorio.

  Nuevo en la versión 3.3.

  Distinto en la versión 3.8: En Windows, path ahora puede ser un archivo o un directorio.

  Disponibilidad: Unix, Windows.

`shutil.``chown`(path, user=None, group=None)

  Cambia el propietario user y/o group de la ruta dada.

  user puede ser un nombre usuario de sistema o un UID (identificador de usuario); lo mismo aplica a group. Se requiere al menos un argumento.

  Véase también `os.chown()`, la función subyacente.

  Genera un evento de auditoría `shutil.chown` con argumentos `path`, `user`, `group`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`shutil.``which`(cmd, mode=os.F_OK | os.X_OK, path=None)

  Retorna la ruta de acceso a un ejecutable que se ejecutaría si el cmd dado se invoca. Si no se invoca a cmd, retorna `None`.

  mode es una máscara de permiso que se pasa a `os.access()`, que determinar por defecto si el archivo existe y es ejecutable.

  Cuando no se especifica path, se usan los resultados de `os.environ()` y se retorna el valor de «PATH» o una reserva de `os.defpath`.

  En Windows, el directorio actual siempre se antepone a path, independientemente de si usa el valor predeterminado o si tú provees el tuyo propio, que es el comportamiento que el comando shell usa cuando encuentra ejecutables. Además, al encontrar el cmd en el path, se comprueba la variable de entorno `PATHEXT`. Por ejemplo, si invocas `shutil.which("python")`, `which()` buscará `PATHEXT` para saber si debe buscar `python.exe` dentro de los directorios path. Por ejemplo, en Windows:

      >>> shutil.which("python")
      'C:\\Python33\\python.EXE'

  Nuevo en la versión 3.3.

  Distinto en la versión 3.8: Ahora se acepta el tipo `bytes`. Si el tipo cmd es `bytes`, el tipo resultante también es `bytes`.

exception `shutil.``Error`

  Esta excepción recopila las excepciones que se generan durante una operación de varios archivos. Para `copytree()`, el argumento de excepción es una lista de 3 tuplas (scrname, dstname, exception).

### Operaciones de copia eficientes dependientes de la plataforma

Starting from Python 3.8, all functions involving a file copy (`copyfile()`, `copy()`, `copy2()`, `copytree()`, and `move()`) may use platform-specific «fast-copy» syscalls in order to copy the file more efficiently (see bpo-33671). «fast-copy» means that the copying operation occurs within the kernel, avoiding the use of userspace buffers in Python as in «`outfd.write(infd.read())`».

En macOS, se usar fcopyfile para copiar el contenido del archivo (pero no los metadatos).

En Linux, se usa `os.sendfile()`.

En Windows, `shutil.copyfile()` usa un tamaño de búfer predeterminado más grande (1 MiB en lugar de 64 KiB) y se usa una variante de `shutil.copyfileobj()` basada en `memoryview()`.

Si ocurre un error en la operación de copia rápida y no se ha escrito ningún dato en el archivo de destino, entonces shutil recurrirá silenciosamente a usar la función `copyfileobj()` menos eficiente internamente.

Distinto en la versión 3.8.

### ejemplo de copytree

Este ejemplo es la implementación de la función `copytree()` , descrita arriba, con la cadena de documentación omitida. Demuestra muchas de las otras funciones provistas por este módulo.

    def copytree(src, dst, symlinks=False):
        names = os.listdir(src)
        os.makedirs(dst)
        errors = []
        for name in names:
            srcname = os.path.join(src, name)
            dstname = os.path.join(dst, name)
            try:
                if symlinks and os.path.islink(srcname):
                    linkto = os.readlink(srcname)
                    os.symlink(linkto, dstname)
                elif os.path.isdir(srcname):
                    copytree(srcname, dstname, symlinks)
                else:
                    copy2(srcname, dstname)
                # XXX What about devices, sockets etc.?
            except OSError as why:
                errors.append((srcname, dstname, str(why)))
            # catch the Error from the recursive copytree so that we can
            # continue with other files
            except Error as err:
                errors.extend(err.args[0])
        try:
            copystat(src, dst)
        except OSError as why:
            # can't copy file access times on Windows
            if why.winerror is None:
                errors.extend((src, dst, str(why)))
        if errors:
            raise Error(errors)

Otro ejemplo que usa el auxiliar `ignore_patterns()`:

    from shutil import copytree, ignore_patterns

    copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))

Esto copiará todo excepto archivos `.pyc` y archivos o directorios cuyo nombre comience con `tmp`.

Otro ejemplo que usa el argumento ignore para agregar una llamada a iniciar sesión:

    from shutil import copytree
    import logging

    def _logpath(path, names):
        logging.info('Working in %s', path)
        return []   # nothing will be ignored

    copytree(source, destination, ignore=_logpath)

### ejemplo de rmtree

Este ejemplo muestra como eliminar un árbol de directorio en Windows donde algunos de los archivos tienen configurado su bit de sólo lectura. Usa la onerror callback para limpiar el bit de sólo lectura y reintentar eliminarlo. Cualquier fallo que le siga, se propagará.

    import os, stat
    import shutil

    def remove_readonly(func, path, _):
        "Clear the readonly bit and reattempt the removal"
        os.chmod(path, stat.S_IWRITE)
        func(path)

    shutil.rmtree(directory, onerror=remove_readonly)

## Operaciones de archivado

Nuevo en la versión 3.2.

Distinto en la versión 3.5: Se agregó soporte para el formato xztar.

Se proveen también las utilidades de alto nivel para crear y leer archivos comprimidos y archivados. Utilizan para esto los módulos `zipfile` y `tarfile`.

`shutil.``make_archive`(base_name, format[, root_dir[, base_dir[, verbose[, dry_run[, owner[, group[, logger]]]]]]])

  Crea un documento de archivado (como zip o tar) y retorna su nombre.

  base_name es el nombre del archivo a crear, incluyendo la ruta, menos cualquier extensión que sea específica de formato. format es el formato de archivo: uno de zip (si el módulo `zlib` está disponible), «tar», «gztar» (si el módulo `zlib` está disponible), «bztar» (si el módulo `bz2` está disponible), o «xztar» (si el módulo `lzma`).

  root_dir is a directory that will be the root directory of the archive, all paths in the archive will be relative to it; for example, we typically chdir into root_dir before creating the archive.

  base_dir is the directory where we start archiving from; i.e. base_dir will be the common prefix of all files and directories in the archive. base_dir must be given relative to root_dir. See Archiving example with base_dir for how to use base_dir and root_dir together.

  root_dir y base_dir irán por defecto al directorio actual.

  If dry_run es verdadero, no se crea un archivo, pero las operaciones que se ejecutarán están registradas en logger.

  owner y group se usan al crear un archivador tar. Por defecto, usa el propietario y el grupo actual.

  logger debe ser un objeto compatible con PEP 282, usualmente una instancia de `logging.Logger`.

  El argumento verbose está fuera de uso y es obsoleto.

  Genera un evento de auditoría `shutil.make_archive` con argumentos `base_name`, `format`, `root_dir`, `base_dir`.

  Nota

  This function is not thread-safe.

  Distinto en la versión 3.8: El formato de pax moderno (POSIX.1-2001) se usa ahora en lugar del formato de legado GNU para archivadores creados con `format="tar"`.

`shutil.``get_archive_formats`()

  Retorna una lista de formatos admitidos para archivado. Cada elemento de una secuencia retornada es una tupla `(name, description)`.

  Por defecto, `shutil` provee los siguientes formatos:

  - zip: archivo ZIP (si el módulo `zlib` está disponible).

  - tar: archivo tar sin comprimir. Utiliza POSIX.1-2001 formato pax para archivos nuevos.

  - gztar: archivo tar comprimido con gzip (si el módulo `zlib` está disponible).

  - bztar: archivo tar comprimido con bzip2 (si el módulo `bz2` está disponible).

  - xztar: archivo tar comprimido con xz (si el módulo `lzma` está disponible).

  Puedes registrar formatos nuevos o proporcionar tu propio archivador para cualquier formato existente, usando `register_archive_format()`.

`shutil.``register_archive_format`(name, function[, extra_args[, description]])

  Registra un archivador para el formato name.

  function es el invocable que se usará para desempacar archivos. El invocable recibirá el base_name del archivo para crearlo, seguido por base_dir (que cae por defecto en `os.curdir`) para comenzar a archivar desde allí. Otros argumentos se pasan como argumentos de palabras clave: owner, group, dry_run y logger (como se pasa en `make_archive()`).

  Si está dado, extra_args es una secuencia de pares `(name, value)` que se usarán como argumentos de palabras clave extra cuando se usa el archivador invocable.

  description se usa por `get_archive_formats()` que retorna la lista de archivadores. Cae por defecto en una cadena de caracteres vacía.

`shutil.``unregister_archive_format`(name)

  Elimina el formato de archivo name de la lista de formatos admitidos.

`shutil.``unpack_archive`(filename[, extract_dir[, format]])

  Desempaqueta un archivo. filename es la ruta completa del archivo.

  extract_dir es el nombre del directorio donde se desempaca el archivo. Si no está provisto, se usa el nombre del directorio actual.

  format es el formato de archivo: uno de «zip», «tar», «gztar», «bztar», or «xztar». O cualquier otra formato registrado con `register_unpack_format()`. Si no está provisto, `unpack_archive()` usará la extensión de archivo del archivador y verá si se registró un desempacador para esa extensión. En caso de que no se encuentre ninguno, se genera un `ValueError`.

  Se genera un evento de auditoría `shutil.unpack_archive` con argumentos `filename`, `extract_dir`, `format`.

  Distinto en la versión 3.7: Acepta un path-like object como filename y extract_dir.

`shutil.``register_unpack_format`(name, extensions, function[, extra_args[, description]])

  Registra un formato de desempaque. name es el nombre del formato y extensions es una lista de extensiones que corresponden al formato, como `.zip` para archivos zip.

  function es el invocable que se usará para desempacar archivadores. El invocable recibirá la ruta del archivador, seguida del directorio al que el archivador debe extraerse.

  Cuando está dado, extra_args es una secuencia de tuplas `(name, value)` que se pasarán como argumentos de palabra clave al invocable.

  description se puede proporcionar para describir el formato y será retornado por la función `get_unpack_formats()`.

`shutil.``unregister_unpack_format`(name)

  Anula el registro del formato de desempaque. name es el nombre del formato.

`shutil.``get_unpack_formats`()

  Retorna una lista de todos los formatos registrados para desempaquetar. Cada elemento de la secuencia es una tupla `(name, extensions, description)`.

  Por defecto, `shutil` provee los siguientes formatos:

  - zip: archivo zip (desempaquetar archivos comprimidos funciona solo si el módulo correspondiente está disponible).

  - tar: archivo tar sin comprimir.

  - gztar: archivo tar comprimido con gzip (si el módulo `zlib` está disponible).

  - bztar: archivo tar comprimido con bzip2 (si el módulo `bz2` está disponible).

  - xztar: archivo tar comprimido con xz (si el módulo `lzma` está disponible).

  Puedes registrar formatos nuevos o proporcionar tu propio desempaquetado para cualquier formato existente, usando `register_unpack_format()`.

### Ejemplo de archivado

En este ejemplo, creamos un archivo tar de tipo gzip que contiene todos los archivos que se encuentran en el directorio `.ssh` del usuario:

    >>> from shutil import make_archive
    >>> import os
    >>> archive_name = os.path.expanduser(os.path.join('~', 'myarchive'))
    >>> root_dir = os.path.expanduser(os.path.join('~', '.ssh'))
    >>> make_archive(archive_name, 'gztar', root_dir)
    '/Users/tarek/myarchive.tar.gz'

El archivo resultante contiene:

    $ tar -tzvf /Users/tarek/myarchive.tar.gz
    drwx------ tarek/staff       0 2010-02-01 16:23:40 ./
    -rw-r--r-- tarek/staff     609 2008-06-09 13:26:54 ./authorized_keys
    -rwxr-xr-x tarek/staff      65 2008-06-09 13:26:54 ./config
    -rwx------ tarek/staff     668 2008-06-09 13:26:54 ./id_dsa
    -rwxr-xr-x tarek/staff     609 2008-06-09 13:26:54 ./id_dsa.pub
    -rw------- tarek/staff    1675 2008-06-09 13:26:54 ./id_rsa
    -rw-r--r-- tarek/staff     397 2008-06-09 13:26:54 ./id_rsa.pub
    -rw-r--r-- tarek/staff   37192 2010-02-06 18:23:10 ./known_hosts

### Archiving example with base_dir

In this example, similar to the one above, we show how to use `make_archive()`, but this time with the usage of base_dir. We now have the following directory structure:

    $ tree tmp
    tmp
    └── root
        └── structure
            ├── content
                └── please_add.txt
            └── do_not_add.txt

In the final archive, `please_add.txt` should be included, but `do_not_add.txt` should not. Therefore we use the following:

    >>> from shutil import make_archive
    >>> import os
    >>> archive_name = os.path.expanduser(os.path.join('~', 'myarchive'))
    >>> make_archive(
    ...     archive_name,
    ...     'tar',
    ...     root_dir='tmp/root',
    ...     base_dir='structure/content',
    ... )
    '/Users/tarek/my_archive.tar'

Listing the files in the resulting archive gives us:

    $ python -m tarfile -l /Users/tarek/myarchive.tar
    structure/content/
    structure/content/please_add.txt

## Consulta el tamaño de la terminal de salida

`shutil.``get_terminal_size`(fallback=(columns, lines))

  Obtén el tamaño de la ventana de la terminal.

  Para cada una de las dos dimensiones, se comprueba la variable de entorno `COLUMNS` y `LINES` respectivamente. Si la variable está definida y el valor es un entero positivo, se utiliza.

  Cuando COLUMNS` o `LINES` no está definido, como suele ocurrir, la terminal conectada a `sys.__stdout__` se consulta invocando `os.get_terminal_size()`.

  Si el tamaño de la terminal no se puede consultar correctamente, ya sea porque el sistema no admite consultas o porque no estamos conectados a una terminal, se usa el valor dado en el parámetro `fallback`. `fallback` tiene por defecto `(80, 24)`, que es el tamaño por defecto que se usa en muchos emuladores de terminal.

  El valor retornado es una tupla con su respectivo nombre, de tipo `os.terminal_size`.

  See also: The Single UNIX Specification, Version 2, Other Environment Variables.

  Nuevo en la versión 3.3.