"tempfile" --- Generate temporary files and directories
*******************************************************

**Code source :** Lib/tempfile.py

======================================================================

This module creates temporary files and directories.  It works on all
supported platforms. "TemporaryFile", "NamedTemporaryFile",
"TemporaryDirectory", and "SpooledTemporaryFile" are high-level
interfaces which provide automatic cleanup and can be used as *context
managers*. "mkstemp()" and "mkdtemp()" are lower-level functions which
require manual cleanup.

Toutes les fonctions et constructeurs appelables par l'utilisateur ont
des arguments additionnels qui permettent de contrôler directement le
chemin et le nom des répertoires et fichiers. Les noms de fichiers
utilisés par ce module incluent une chaîne de caractères aléatoires
qui leur permet d'être créés de manière sécurisée dans des répertoires
temporaires partagés. Afin de maintenir la compatibilité descendante,
l'ordre des arguments est quelque peu étrange ; pour des questions de
clarté, il est recommandé d'utiliser les arguments nommés.

Le module définit les éléments suivants pouvant être appelés par
l'utilisateur :

tempfile.TemporaryFile(mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, *, errors=None)

   Renvoie un *objet fichier* qui peut être utilisé comme une zone de
   stockage temporaire. Le fichier est créé de manière sécurisée,
   utilisant les mêmes règles que "mkstemp()". Il sera détruit dès
   qu'il sera fermé (y compris lorsque le fichier est implicitement
   fermé quand il est collecté par le ramasse-miettes). Sous Unix,
   soit l'entrée du répertoire n'est pas du tout créée, soit elle est
   supprimée immédiatement après la création du fichier. Les autres
   plateformes ne gèrent pas cela, votre code ne doit pas compter sur
   un fichier temporaire créé en utilisant cette fonction ayant ou non
   un nom visible sur le système de fichiers.

   The resulting object can be used as a *context manager* (see
   Exemples).  On completion of the context or destruction of the file
   object the temporary file will be removed from the filesystem.

   Le paramètre *mode* vaut par défaut "'w+b'" afin que le fichier
   créé puisse être lu et écrit sans être fermé. Le mode binaire est
   utilisé afin que le comportement soit le même sur toutes les
   plateformes quelle que soit la donnée qui est stockée. *buffering*,
   *encoding*, *errors* et *newline* sont interprétés de la même façon
   que pour "open()".

   Les paramètres *dir*, *prefix* et *suffix* ont la même
   signification et les mêmes valeurs par défaut que dans "mkstemp()".

   L'objet renvoyé est un véritable fichier sur les plateformes POSIX.
   Sur les autres plateformes, c'est un objet fichier-compatible, dont
   l'attribut "file" donne le véritable fichier.

   The "os.O_TMPFILE" flag is used if it is available and works
   (Linux-specific, requires Linux kernel 3.11 or later).

   Sur les plateformes qui ne sont pas POSIX ni Cygwin,
   "TemporaryFile" est un alias de "NamedTemporaryFile".

   Lève un évènement d'audit "tempfile.mkstemp" avec comme argument
   "fullpath".

   Modifié dans la version 3.5: The "os.O_TMPFILE" flag is now used if
   available.

   Modifié dans la version 3.8: Le paramètre *errors* a été ajouté.

tempfile.NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, delete=True, *, errors=None, delete_on_close=True)

   This function operates exactly as "TemporaryFile()" does, except
   the following differences:

   * This function returns a file that is guaranteed to have a visible
     name in the file system.

   * To manage the named file, it extends the parameters of
     "TemporaryFile()" with *delete* and *delete_on_close* parameters
     that determine whether and how the named file should be
     automatically deleted.

   The returned object is always a *file-like object* whose "file"
   attribute is the underlying true file object. This file-like object
   can be used in a "with" statement, just like a normal file.  The
   name of the temporary file can be retrieved from the "name"
   attribute of the returned file-like object. On Unix, unlike with
   the "TemporaryFile()", the directory entry does not get unlinked
   immediately after the file creation.

   If *delete* is true (the default) and *delete_on_close* is true
   (the default), the file is deleted as soon as it is closed. If
   *delete* is true and *delete_on_close* is false, the file is
   deleted on context manager exit only, or else when the *file-like
   object* is finalized. Deletion is not always guaranteed in this
   case (see "object.__del__()"). If *delete* is false, the value of
   *delete_on_close* is ignored.

   Therefore to use the name of the temporary file to reopen the file
   after closing it, either make sure not to delete the file upon
   closure (set the *delete* parameter to be false) or, in case the
   temporary file is created in a "with" statement, set the
   *delete_on_close* parameter to be false. The latter approach is
   recommended as it provides assistance in automatic cleaning of the
   temporary file upon the context manager exit.

   Opening the temporary file again by its name while it is still open
   works as follows:

   * On POSIX the file can always be opened again.

   * On Windows, make sure that at least one of the following
     conditions are fulfilled:

     * *delete* is false

     * additional open shares delete access (e.g. by calling
       "os.open()" with the flag "O_TEMPORARY")

     * *delete* is true but *delete_on_close* is false. Note, that in
       this case the additional opens that do not share delete access
       (e.g. created via builtin "open()") must be closed before
       exiting the context manager, else the "os.unlink()" call on
       context manager exit will fail with a "PermissionError".

   On Windows, if *delete_on_close* is false, and the file is created
   in a directory for which the user lacks delete access, then the
   "os.unlink()" call on exit of the context manager will fail with a
   "PermissionError". This cannot happen when *delete_on_close* is
   true because delete access is requested by the open, which fails
   immediately if the requested access is not granted.

   On POSIX (only), a process that is terminated abruptly with SIGKILL
   cannot automatically delete any NamedTemporaryFiles it created.

   Lève un évènement d'audit "tempfile.mkstemp" avec comme argument
   "fullpath".

   Modifié dans la version 3.8: Le paramètre *errors* a été ajouté.

   Modifié dans la version 3.12: Added *delete_on_close* parameter.

class tempfile.SpooledTemporaryFile(max_size=0, mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, *, errors=None)

   This class operates exactly as "TemporaryFile()" does, except that
   data is spooled in memory until the file size exceeds *max_size*,
   or until the file's "fileno()" method is called, at which point the
   contents are written to disk and operation proceeds as with
   "TemporaryFile()".

   rollover()

      The resulting file has one additional method, "rollover()",
      which causes the file to roll over to an on-disk file regardless
      of its size.

   The returned object is a file-like object whose "_file" attribute
   is either an "io.BytesIO" or "io.TextIOWrapper" object (depending
   on whether binary or text *mode* was specified) or a true file
   object, depending on whether "rollover()" has been called.  This
   file-like object can be used in a "with" statement, just like a
   normal file.

   Modifié dans la version 3.3: the truncate method now accepts a
   *size* argument.

   Modifié dans la version 3.8: Le paramètre *errors* a été ajouté.

   Modifié dans la version 3.11: Fully implements the
   "io.BufferedIOBase" and "io.TextIOBase" abstract base classes
   (depending on whether binary or text *mode* was specified).

class tempfile.TemporaryDirectory(suffix=None, prefix=None, dir=None, ignore_cleanup_errors=False, *, delete=True)

   This class securely creates a temporary directory using the same
   rules as "mkdtemp()". The resulting object can be used as a
   *context manager* (see Exemples).  On completion of the context or
   destruction of the temporary directory object, the newly created
   temporary directory and all its contents are removed from the
   filesystem.

   name

      The directory name can be retrieved from the "name" attribute of
      the returned object.  When the returned object is used as a
      *context manager*, the "name" will be assigned to the target of
      the "as" clause in the "with" statement, if there is one.

   cleanup()

      The directory can be explicitly cleaned up by calling the
      "cleanup()" method. If *ignore_cleanup_errors* is true, any
      unhandled exceptions during explicit or implicit cleanup (such
      as a "PermissionError" removing open files on Windows) will be
      ignored, and the remaining removable items deleted on a "best-
      effort" basis. Otherwise, errors will be raised in whatever
      context cleanup occurs (the "cleanup()" call, exiting the
      context manager, when the object is garbage-collected or during
      interpreter shutdown).

   The *delete* parameter can be used to disable cleanup of the
   directory tree upon exiting the context.  While it may seem unusual
   for a context manager to disable the action taken when exiting the
   context, it can be useful during debugging or when you need your
   cleanup behavior to be conditional based on other logic.

   Lève un évènement d'audit "tempfile.mkdtemp" avec comme argument
   "fullpath".

   Ajouté dans la version 3.2.

   Modifié dans la version 3.10: ajout du paramètre
   *ignore_cleanup_errors*.

   Modifié dans la version 3.12: Added the *delete* parameter.

tempfile.mkstemp(suffix=None, prefix=None, dir=None, text=False)

   Crée un fichier temporaire de la manière la plus sécurisée qui
   soit. Il n'y a pas de problème d'accès concurrent (*race condition*
   en anglais) au moment de la création du fichier, en supposant que
   la plateforme implémente correctement l'option "os.O_EXCL" pour
   "os.open()". Le fichier est seulement accessible en lecture et
   écriture par l'ID de l'utilisateur créateur. Si la plateforme
   utilise des bits de permissions pour indiquer si le fichier est
   exécutable, alors le fichier n'est exécutable par personne. Le
   descripteur de fichier n'est pas hérité par les processus fils.

   À la différence de "TemporaryFile()", l'utilisateur de "mkstemp()"
   est responsable de la suppression du fichier temporaire quand il
   n'en a plus besoin.

   Si *suffix* ne vaut pas "None", le nom de fichier se terminera avec
   ce suffixe, sinon il n'y aura pas de suffixe. "mkstemp()" ne met
   pas de point entre le nom du fichier et le suffixe. Si vous en avez
   besoin, mettez le point au début de *suffix*.

   Si *prefix* ne vaut pas "None", le nom de fichier commencera avec
   ce préfixe, sinon un préfixe par défaut est utilisé. La valeur par
   défaut est la valeur retournée par "gettempprefix()" ou
   "gettempprefixb()".

   Si *dir* ne vaut pas "None", le fichier sera créé dans ce
   répertoire, autrement, un répertoire par défaut sera utilisé. Le
   répertoire par défaut est choisi depuis une liste dépendante de la
   plateforme, mais l'utilisateur de l'application peut contrôler
   l'emplacement du répertoire en spécifiant les variables
   d'environnement *TMPDIR*, *TEMP* ou *TMP*. Il n'y a pas de garantie
   que le nom de fichier généré aura de bonnes propriétés telles que
   ne pas avoir besoin de le mettre entre guillemets lorsque celui-ci
   est passé à des commandes externes via "os.popen()".

   Si l'un des paramètres *suffix*, *prefix* et *dir* n'est pas
   "None", ils doivent être du même type. S'ils sont de type "bytes",
   le nom renvoyé est de type "bytes" plutôt que de type "str". Si
   vous voulez forcer la valeur renvoyée en "bytes", passez
   "suffix=b''".

   Le fichier est ouvert en mode binaire, sauf si *text* est mis à
   vrai, auquel cas il est ouvert en mode textuel.

   "mkstemp()" renvoie une paire contenant un descripteur (*handle* en
   anglais) au niveau du système d'exploitation vers un fichier ouvert
   (le même que renvoie "os.open()") et le chemin d'accès absolu de ce
   fichier, dans cet ordre.

   Lève un évènement d'audit "tempfile.mkstemp" avec comme argument
   "fullpath".

   Modifié dans la version 3.5: *suffix*, *prefix*, et *dir* peuvent
   maintenant être spécifiés en "bytes" pour obtenir un résultat en
   "bytes". Avant cela, le type "str" était le seul autorisé. *suffix*
   et *prefix* acceptent maintenant la valeur par défaut "None" pour
   que la valeur par défaut appropriée soit utilisée.

   Modifié dans la version 3.6: Le paramètre *dir* accepte un *objet
   fichier-compatible*.

tempfile.mkdtemp(suffix=None, prefix=None, dir=None)

   Crée un répertoire temporaire de la manière la plus sécurisée qu'il
   soit. Il n'y a pas de problème d'accès concurrent (*race condition*
   en anglais) au moment de la création du répertoire. Le répertoire
   est accessible en lecture, en écriture, et son contenu lisible
   uniquement pour l'ID de l'utilisateur créateur.

   L'utilisateur de "mkdtemp()" est responsable de la suppression du
   répertoire temporaire et de son contenu lorsqu'il n'en a plus
   besoin.

   Les arguments *prefix*, *suffix*, et *dir* sont les mêmes que pour
   "mkstemp()".

   "mkdtemp()" renvoie le chemin absolu du nouveau répertoire.

   Lève un évènement d'audit "tempfile.mkdtemp" avec comme argument
   "fullpath".

   Modifié dans la version 3.5: *suffix*, *prefix*, et *dir* peuvent
   maintenant être spécifiés en "bytes" pour obtenir un résultat en
   "bytes". Avant cela, le type "str" était le seul autorisé. *suffix*
   et *prefix* acceptent maintenant la valeur par défaut "None" pour
   que la valeur par défaut appropriée soit utilisée.

   Modifié dans la version 3.6: Le paramètre *dir* accepte un *objet
   fichier-compatible*.

   Modifié dans la version 3.12: "mkdtemp()" now always returns an
   absolute path, even if *dir* is relative.

tempfile.gettempdir()

   Renvoie le nom du répertoire utilisé pour les fichiers temporaires.
   C'est la valeur par défaut pour l'argument *dir* de toutes les
   fonctions de ce module.

   Python cherche un répertoire parmi une liste standard de
   répertoires dans lequel l'utilisateur final peut créer des
   fichiers. La liste est :

   1. Le répertoire correspondant à la variable d'environnement
      "TMPDIR".

   2. Le répertoire correspondant à la variable d'environnement
      "TEMP".

   3. Le répertoire correspondant à la variable d'environnement "TMP".

   4. Un emplacement dépendant de la plateforme :

      * Sur Windows, les répertoires "C:\TEMP", "C:\TMP", "\TEMP", et
        "\TMP", dans cet ordre.

      * Sur toutes les autres plate-formes, les répertoires "/tmp",
        "/var/tmp", et "/usr/tmp", dans cet ordre.

   5. En dernier ressort, le répertoire de travail courant.

   Le résultat de cette recherche est mis en cache, voir la
   description de "tempdir" dessous.

   Modifié dans la version 3.10: Cette fonction renvoie désormais
   systématiquement une chaîne de caractères. Auparavant, elle pouvait
   renvoyer la valeur de "tempdir" quel que soit son type tant que ce
   n'était pas "None".

tempfile.gettempdirb()

   Similaire à "gettempdir()" mais la valeur retournée est en *bytes*.

   Ajouté dans la version 3.5.

tempfile.gettempprefix()

   Renvoie le préfixe de nom de fichier utilisé pour créer les
   fichiers temporaires. Cela ne contient pas le nom du répertoire.

tempfile.gettempprefixb()

   Similaire à "gettempprefix()" mais la valeur retournée est en
   *bytes*.

   Ajouté dans la version 3.5.

Le module utilise une variable globale pour stocker le nom du
répertoire utilisé pour les fichiers temporaires renvoyés par
"gettempdir()". Vous pouvez directement utiliser la variable globale
pour surcharger le processus de sélection, mais ceci est déconseillé.
Toutes les fonctions de ce module prennent un argument *dir* qui peut
être utilisé pour spécifier le répertoire. Il s'agit de la méthode
recommandée car elle n'interfère pas avec le code extérieur en
modifiant le comportement global du module.

tempfile.tempdir

   Quand une valeur autre que "None" est spécifiée, cette variable
   définit la valeur par défaut pour l'argument *dir* des fonctions
   définies dans ce module, et en particulier son type ("bytes" ou
   "str"). Les *objets fichier-compatibles* ne sont pas acceptés.

   Si "tempdir" vaut "None" (par défaut) pour n'importe laquelle des
   fonctions ci-dessus, sauf "gettempprefix()", la variable est
   initialisée suivant l'algorithme décrit dans "gettempdir()".

   Note:

     Attention, le fait de mettre "tempdir" à une valeur de type
     "bytes" a l'effet pervers de changer globalement en "bytes" le
     type de retour de "mkstemp()" et "mkdtemp()" lorsqu'elles sont
     appelées sans qu'aucun des paramètres *prefix*, *suffix* et *dir*
     ne soit de type "str". Ce comportement par défaut surprenant est
     préservé par souci de compatibilité avec l'implémentation
     historique du module. Il est fortement recommandé de ne pas s'y
     fier.


Exemples
========

Voici quelques exemples classiques d'utilisation du module "tempfile"
:

   >>> import tempfile

   # create a temporary file and write some data to it
   >>> fp = tempfile.TemporaryFile()
   >>> fp.write(b'Hello world!')
   # read data from file
   >>> fp.seek(0)
   >>> fp.read()
   b'Hello world!'
   # close the file, it will be removed
   >>> fp.close()

   # create a temporary file using a context manager
   >>> with tempfile.TemporaryFile() as fp:
   ...     fp.write(b'Hello world!')
   ...     fp.seek(0)
   ...     fp.read()
   b'Hello world!'
   >>>
   # file is now closed and removed

   # create a temporary file using a context manager
   # close the file, use the name to open the file again
   >>> with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
   ...     fp.write(b'Hello world!')
   ...     fp.close()
   ... # the file is closed, but not removed
   ... # open the file again by using its name
   ...     with open(fp.name, mode='rb') as f:
   ...         f.read()
   b'Hello world!'
   >>>
   # file is now removed

   # create a temporary directory using the context manager
   >>> with tempfile.TemporaryDirectory() as tmpdirname:
   ...     print('created temporary directory', tmpdirname)
   >>>
   # directory and contents have been removed


Fonctions et variables obsolètes
================================

Historiquement, la méthode pour créer des fichiers temporaires
consistait à générer un nom de fichier avec la fonction "mktemp()"
puis créer un fichier en utilisant ce nom. Malheureusement, cette
méthode n'est pas fiable car un autre processus peut créer un fichier
avec ce nom entre l'appel à la fonction "mktemp()" et la tentative de
création de fichier par le premier processus en cours. La solution est
de combiner les deux étapes et de créer le fichier immédiatement.
Cette approche est utilisée par "mkstemp()" et les autres fonctions
décrites plus haut.

tempfile.mktemp(suffix='', prefix='tmp', dir=None)

   Obsolète depuis la version 2.3: Utilisez "mkstemp()" à la place.

   Renvoie le chemin absolu d'un fichier qui n'existe pas lorsque
   l'appel est fait. Les arguments *prefix*, *suffix*, et *dir* sont
   similaires à ceux de "mkstemp()" mais les noms de fichiers en
   *bytes*, "sufix=None" et "prefix=None" ne sont pas implémentées.

   Avertissement:

     Utiliser cette fonction peut introduire une faille de sécurité
     dans votre programme. Avant que vous n'ayez le temps de faire
     quoi que ce soit avec le nom de fichier renvoyé, quelqu'un peut
     l'utiliser. L'utilisation de "mktemp()" peut être remplacée
     facilement avec "NamedTemporaryFile()" en y passant le paramètre
     "delete=False" :

        >>> f = NamedTemporaryFile(delete=False)
        >>> f.name
        '/tmp/tmptjujjt'
        >>> f.write(b"Hello World!\n")
        13
        >>> f.close()
        >>> os.unlink(f.name)
        >>> os.path.exists(f.name)
        False
