python-docs-fr/library/zipapp.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.5\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:42+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/library/zipapp.rst:2
msgid ":mod:`zipapp` --- Manage executable python zip archives"
msgstr ""

#: ../Doc/library/zipapp.rst:9
msgid "**Source code:** :source:`Lib/zipapp.py`"
msgstr "**Code source :** :source:`Lib/zipapp.py`"

#: ../Doc/library/zipapp.rst:16
msgid ""
"This module provides tools to manage the creation of zip files containing "
"Python code, which can be  :ref:`executed directly by the Python interpreter "
"<using-on-interface-options>`.  The module provides both a :ref:`zipapp-"
"command-line-interface` and a :ref:`zipapp-python-api`."
msgstr ""
"Ce module fournit des outils pour gérer la création de fichiers zip "
"contenant du code Python, qui peuvent être :ref:`exécutés directement par "
"l'interpréteur Python <using-on-interface-options>`.  Le module fournit à la "
"fois une interface de ligne de commande :ref:`zipapp-command-line-interface` "
"et une interface :ref:`zipapp-python-api`."

#: ../Doc/library/zipapp.rst:23
msgid "Basic Example"
msgstr "Exemple de base"

#: ../Doc/library/zipapp.rst:25
msgid ""
"The following example shows how the :ref:`zipapp-command-line-interface` can "
"be used to create an executable archive from a directory containing Python "
"code.  When run, the archive will execute the ``main`` function from the "
"module ``myapp`` in the archive."
msgstr ""
"L'exemple suivant montre comment l'interface de ligne de commande :ref:"
"`zipapp-command-line-interface` peut être utilisée pour créer une archive "
"exécutable depuis un répertoire contenant du code Python.  Lors de "
"l'exécution, l'archive exécutera la fonction ``main`` du module ``myapp`` "
"dans l'archive."

#: ../Doc/library/zipapp.rst:40
msgid "Command-Line Interface"
msgstr "Interface en ligne de commande"

#: ../Doc/library/zipapp.rst:42
msgid ""
"When called as a program from the command line, the following form is used:"
msgstr ""
"Lorsqu'il est appelé en tant que programme à partir de la ligne de commande, "
"la syntaxe suivante est utilisée :"

#: ../Doc/library/zipapp.rst:48
msgid ""
"If *source* is a directory, this will create an archive from the contents of "
"*source*.  If *source* is a file, it should be an archive, and it will be "
"copied to the target archive (or the contents of its shebang line will be "
"displayed if the --info option is specified)."
msgstr ""
"Si *source* est un répertoire, une archive est créée à partir du contenu de "
"*source*.  Si *source* est un fichier, ce doit être une archive et il est "
"copié dans l'archive cible (ou le contenu de sa ligne `shebang` est affiché "
"si l'option ``--info`` est indiquée)."

#: ../Doc/library/zipapp.rst:53
msgid "The following options are understood:"
msgstr "Les options suivantes sont disponibles :"

#: ../Doc/library/zipapp.rst:59
msgid ""
"Write the output to a file named *output*.  If this option is not specified, "
"the output filename will be the same as the input *source*, with the "
"extension ``.pyz`` added.  If an explicit filename is given, it is used as "
"is (so a ``.pyz`` extension should be included if required)."
msgstr ""
"Écrit la sortie dans un fichier nommé *output*.  Si cette option n'est pas "
"spécifiée, le nom du fichier de sortie sera le même que celui de l'entrée "
"*source*, avec l'extension ``.pyz``.  Si un nom de fichier explicite est "
"donné, il est utilisé tel quel (une extension ``.pyz`` doit donc être "
"incluse si nécessaire)."

#: ../Doc/library/zipapp.rst:64
msgid ""
"An output filename must be specified if the *source* is an archive (and in "
"that case, *output* must not be the same as *source*)."
msgstr ""
"Un nom de fichier de sortie doit être spécifié si la *source* est une "
"archive (et, dans ce cas, la *sortie* ne doit pas être la même que la "
"*source*)."

#: ../Doc/library/zipapp.rst:69
msgid ""
"Add a ``#!`` line to the archive specifying *interpreter* as the command to "
"run.  Also, on POSIX, make the archive executable.  The default is to write "
"no ``#!`` line, and not make the file executable."
msgstr ""
"Ajoute une ligne ``#!`` à l'archive en spécifiant *interpreter* comme "
"commande à exécuter.  Aussi, sur un système POSIX, cela rend l'archive "
"exécutable.  Le comportement par défaut est de ne pas écrire la ligne ``#!`` "
"et de ne pas rendre le fichier exécutable."

#: ../Doc/library/zipapp.rst:75
msgid ""
"Write a ``__main__.py`` file to the archive that executes *mainfn*.  The "
"*mainfn* argument should have the form \"pkg.mod:fn\", where \"pkg.mod\" is "
"a package/module in the archive, and \"fn\" is a callable in the given "
"module. The ``__main__.py`` file will execute that callable."
msgstr ""
"Écrit un fichier ``__main__.py`` dans l'archive qui exécute *mainfn*.  "
"L'argument *mainfn* est de la forme « *pkg.mod:fn* », où « *pkg.mod* » est "
"un paquet/module dans l'archive, et « *fn* » est un appelable dans le module "
"donné. Le fichier ``__main__.py`` réalise cet appel."

#: ../Doc/library/zipapp.rst:80
msgid ":option:`--main` cannot be specified when copying an archive."
msgstr ""
":option:`--main` ne peut pas être spécifié lors de la copie d'une archive."

#: ../Doc/library/zipapp.rst:84
msgid ""
"Display the interpreter embedded in the archive, for diagnostic purposes.  "
"In this case, any other options are ignored and SOURCE must be an archive, "
"not a directory."
msgstr ""
"Affiche l'interpréteur intégré dans l'archive, à des fins de diagnostic.  "
"Dans ce cas, toutes les autres options sont ignorées et SOURCE doit être une "
"archive et non un répertoire."

#: ../Doc/library/zipapp.rst:90
msgid "Print a short usage message and exit."
msgstr "Affiche un court message d'aide et quitte."

#: ../Doc/library/zipapp.rst:96
msgid "Python API"
msgstr "API Python"

#: ../Doc/library/zipapp.rst:98
msgid "The module defines two convenience functions:"
msgstr "Ce module définit deux fonctions utilitaires :"

#: ../Doc/library/zipapp.rst:103
msgid ""
"Create an application archive from *source*.  The source can be any of the "
"following:"
msgstr ""
"Crée une archive d'application à partir de *source*.  La source peut être de "
"natures suivantes :"

#: ../Doc/library/zipapp.rst:106
msgid ""
"The name of a directory, or a :class:`pathlib.Path` object referring to a "
"directory, in which case a new application archive will be created from the "
"content of that directory."
msgstr ""

#: ../Doc/library/zipapp.rst:109
msgid ""
"The name of an existing application archive file, or a :class:`pathlib.Path` "
"object referring to such a file, in which case the file is copied to the "
"target (modifying it to reflect the value given for the *interpreter* "
"argument).  The file name should include the ``.pyz`` extension, if required."
msgstr ""

#: ../Doc/library/zipapp.rst:113
msgid ""
"A file object open for reading in bytes mode.  The content of the file "
"should be an application archive, and the file object is assumed to be "
"positioned at the start of the archive."
msgstr ""
"Un objet fichier ouvert pour la lecture en mode binaire.  Le contenu du "
"fichier doit être une archive d'application et Python suppose que l'objet "
"fichier est positionné au début de l'archive."

#: ../Doc/library/zipapp.rst:117
msgid ""
"The *target* argument determines where the resulting archive will be written:"
msgstr "L'argument *target* détermine où l'archive résultante sera écrite :"

#: ../Doc/library/zipapp.rst:120
msgid ""
"If it is the name of a file, or a :class:`pathlb.Path` object, the archive "
"will be written to that file."
msgstr ""

#: ../Doc/library/zipapp.rst:122
msgid ""
"If it is an open file object, the archive will be written to that file "
"object, which must be open for writing in bytes mode."
msgstr ""
"S'il s'agit d'un objet fichier ouvert, l'archive sera écrite dans cet objet "
"fichier, qui doit être ouvert pour l'écriture en mode octets."

#: ../Doc/library/zipapp.rst:124
msgid ""
"If the target is omitted (or ``None``), the source must be a directory and "
"the target will be a file with the same name as the source, with a ``.pyz`` "
"extension added."
msgstr ""
"Si la cible est omise (ou ``None``), la source doit être un répertoire et la "
"cible sera un fichier portant le même nom que la source, avec une extension "
"``.pyz`` ajoutée."

#: ../Doc/library/zipapp.rst:128
msgid ""
"The *interpreter* argument specifies the name of the Python interpreter with "
"which the archive will be executed.  It is written as a \"shebang\" line at "
"the start of the archive.  On POSIX, this will be interpreted by the OS, and "
"on Windows it will be handled by the Python launcher.  Omitting the "
"*interpreter* results in no shebang line being written.  If an interpreter "
"is specified, and the target is a filename, the executable bit of the target "
"file will be set."
msgstr ""
"L'argument *interpreter* spécifie le nom de l'interpréteur Python avec "
"lequel l'archive sera exécutée.  Il est écrit dans une ligne *shebang* au "
"début de l'archive.  Sur un système POSIX, cela est interprété par le "
"système d'exploitation et, sur Windows, il sera géré par le lanceur Python.  "
"L'omission de l'*interpreter* n'entraîne pas l'écriture d'une ligne "
"*shebang*.  Si un interpréteur est spécifié et que la cible est un nom de "
"fichier, le bit exécutable du fichier cible sera mis à 1."

#: ../Doc/library/zipapp.rst:136
msgid ""
"The *main* argument specifies the name of a callable which will be used as "
"the main program for the archive.  It can only be specified if the source is "
"a directory, and the source does not already contain a ``__main__.py`` "
"file.  The *main* argument should take the form \"pkg.module:callable\" and "
"the archive will be run by importing \"pkg.module\" and executing the given "
"callable with no arguments.  It is an error to omit *main* if the source is "
"a directory and does not contain a ``__main__.py`` file, as otherwise the "
"resulting archive would not be executable."
msgstr ""
"L'argument *main* spécifie le nom d'un appelable, utilisé comme programme "
"principal pour l'archive.  Il ne peut être spécifié que si la source est un "
"répertoire et si la source ne contient pas déjà un fichier ``__main__.py``.  "
"L'argument *main* doit prendre la forme ``pkg.module:callable`` et l'archive "
"sera exécutée en important ``pkg.module`` et en exécutant l'appelable donné "
"sans argument.  Omettre *main* est une erreur si la source est un répertoire "
"et ne contient pas un fichier ``__main__.py`` car, dans ce cas, l'archive "
"résultante ne serait pas exécutable."

#: ../Doc/library/zipapp.rst:146
msgid ""
"If a file object is specified for *source* or *target*, it is the caller's "
"responsibility to close it after calling create_archive."
msgstr ""
"Si un objet fichier est spécifié pour *source* ou *target*, il est de la "
"responsabilité de l'appelant de le fermer après avoir appelé "
"``create_archive``."

#: ../Doc/library/zipapp.rst:149
msgid ""
"When copying an existing archive, file objects supplied only need ``read`` "
"and ``readline``, or ``write`` methods.  When creating an archive from a "
"directory, if the target is a file object it will be passed to the ``zipfile."
"ZipFile`` class, and must supply the methods needed by that class."
msgstr ""
"Lors de la copie d'une archive existante, les objets fichier fournis n'ont "
"besoin que des méthodes ``read`` et ``readline`` ou ``write``.  Lors de la "
"création d'une archive à partir d'un répertoire, si la cible est un objet "
"fichier, elle sera passée à la classe ``zipfile.ZipFile`` et devra fournir "
"les méthodes nécessaires à cette classe."

#: ../Doc/library/zipapp.rst:157
msgid ""
"Return the interpreter specified in the ``#!`` line at the start of the "
"archive.  If there is no ``#!`` line, return :const:`None`. The *archive* "
"argument can be a filename or a file-like object open for reading in bytes "
"mode.  It is assumed to be at the start of the archive."
msgstr ""
"Renvoie l'interpréteur spécifié dans la ligne ``#!`` au début de l'archive.  "
"S'il n'y a pas de ligne ``#!``, renvoie :const:`None`. L'argument *archive* "
"peut être un nom de fichier ou un objet de type fichier ouvert à la lecture "
"en mode binaire. Python suppose qu'il est au début de l'archive."

#: ../Doc/library/zipapp.rst:166
msgid "Examples"
msgstr "Exemples"

#: ../Doc/library/zipapp.rst:168
msgid "Pack up a directory into an archive, and run it."
msgstr "Regroupe le contenu d'un répertoire dans une archive, puis l'exécute."

#: ../Doc/library/zipapp.rst:176
msgid "The same can be done using the :func:`create_archive` functon::"
msgstr ""

#: ../Doc/library/zipapp.rst:181
msgid ""
"To make the application directly executable on POSIX, specify an interpreter "
"to use."
msgstr ""
"Pour rendre l'application directement exécutable sur un système POSIX, "
"spécifiez un interpréteur à utiliser."

#: ../Doc/library/zipapp.rst:190
msgid ""
"To replace the shebang line on an existing archive, create a modified "
"archive using the :func:`create_archive` function::"
msgstr ""
"Pour remplacer la ligne *shebang* sur une archive existante, créez une "
"archive modifiée en utilisant la fonction :func:`create_archive` : ::"

#: ../Doc/library/zipapp.rst:196
msgid ""
"To update the file in place, do the replacement in memory using a :class:"
"`BytesIO` object, and then overwrite the source afterwards.  Note that there "
"is a risk when overwriting a file in place that an error will result in the "
"loss of the original file.  This code does not protect against such errors, "
"but production code should do so.  Also, this method will only work if the "
"archive fits in memory::"
msgstr ""
"Pour mettre à jour le fichier sans créer de copie locale, effectuez le "
"remplacement en mémoire à l'aide d'un objet :class:`BytesIO`, puis écrasez "
"la source par la suite.  Notez qu'il y a un risque lors de l'écrasement d'un "
"fichier local qu'une erreur entraîne la perte du fichier original.  Ce code "
"ne protège pas contre de telles erreurs, assurez-vous de prendre les mesures "
"nécessaires en production.  De plus, cette méthode ne fonctionnera que si "
"l'archive tient en mémoire : ::"

#: ../Doc/library/zipapp.rst:210
msgid ""
"Note that if you specify an interpreter and then distribute your application "
"archive, you need to ensure that the interpreter used is portable.  The "
"Python launcher for Windows supports most common forms of POSIX ``#!`` line, "
"but there are other issues to consider:"
msgstr ""
"Notez que si vous spécifiez un interpréteur et que vous distribuez ensuite "
"votre archive d'application, vous devez vous assurer que l'interpréteur "
"utilisé est portable.  Le lanceur Python pour Windows gère la plupart des "
"formes courantes de la ligne POSIX ``#!``, mais il y a d'autres problèmes à "
"considérer :"

#: ../Doc/library/zipapp.rst:215
msgid ""
"If you use \"/usr/bin/env python\" (or other forms of the \"python\" "
"command, such as \"/usr/bin/python\"), you need to consider that your users "
"may have either Python 2 or Python 3 as their default, and write your code "
"to work under both versions."
msgstr ""
"Si vous utilisez ``/usr/bin/env python`` (ou d'autres formes de la commande "
"*python*, comme ``/usr/bin/python``), vous devez considérer que vos "
"utilisateurs peuvent avoir Python 2 ou Python 3 par défaut, et écrire votre "
"code pour fonctionner dans les deux versions."

#: ../Doc/library/zipapp.rst:219
msgid ""
"If you use an explicit version, for example \"/usr/bin/env python3\" your "
"application will not work for users who do not have that version.  (This may "
"be what you want if you have not made your code Python 2 compatible)."
msgstr ""
"Si vous utilisez une version explicite, par exemple ``/usr/bin/env python3`` "
"votre application ne fonctionnera pas pour les utilisateurs qui n'ont pas "
"cette version.  (C'est peut-être ce que vous voulez si vous n'avez pas rendu "
"votre code compatible Python 2)."

#: ../Doc/library/zipapp.rst:222
msgid ""
"There is no way to say \"python X.Y or later\", so be careful of using an "
"exact version like \"/usr/bin/env python3.4\" as you will need to change "
"your shebang line for users of Python 3.5, for example."
msgstr ""
"Il n'y a aucun moyen de dire « python X.Y ou supérieur » donc faites "
"attention si vous utilisez une version exacte comme ``/usr/bin/env "
"python3.4`` car vous devrez changer votre ligne *shebang* pour les "
"utilisateurs de Python 3.5, par exemple."

#: ../Doc/library/zipapp.rst:227
msgid "The Python Zip Application Archive Format"
msgstr "Le format d'archive d'application Zip Python"

#: ../Doc/library/zipapp.rst:229
msgid ""
"Python has been able to execute zip files which contain a ``__main__.py`` "
"file since version 2.6.  In order to be executed by Python, an application "
"archive simply has to be a standard zip file containing a ``__main__.py`` "
"file which will be run as the entry point for the application.  As usual for "
"any Python script, the parent of the script (in this case the zip file) will "
"be placed on :data:`sys.path` and thus further modules can be imported from "
"the zip file."
msgstr ""
"Python est capable d'exécuter des fichiers zip qui contiennent un fichier "
"``__main__.py`` depuis la version 2.6.  Pour être exécutée par Python, une "
"archive d'application doit simplement être un fichier zip standard contenant "
"un fichier ``__main__.py`` qui sera exécuté comme point d'entrée de "
"l'application.  Comme d'habitude pour tout script Python, le parent du "
"script (dans ce cas le fichier zip) sera placé sur :data:`sys.path` et ainsi "
"d'autres modules pourront être importés depuis le fichier zip."

#: ../Doc/library/zipapp.rst:236
msgid ""
"The zip file format allows arbitrary data to be prepended to a zip file.  "
"The zip application format uses this ability to prepend a standard POSIX "
"\"shebang\" line to the file (``#!/path/to/interpreter``)."
msgstr ""
"Le format de fichier zip permet d'ajouter des données arbitraires à un "
"fichier zip.  Le format de l'application zip utilise cette possibilité pour "
"préfixer une ligne *shebang* POSIX standard dans le fichier (``#!/path/to/"
"interpreter``)."

#: ../Doc/library/zipapp.rst:240
msgid "Formally, the Python zip application format is therefore:"
msgstr "Formellement, le format d'application zip de Python est donc :"

#: ../Doc/library/zipapp.rst:242
msgid ""
"An optional shebang line, containing the characters ``b'#!'`` followed by an "
"interpreter name, and then a newline (``b'\\n'``) character.  The "
"interpreter name can be anything acceptable to the OS \"shebang\" "
"processing, or the Python launcher on Windows.  The interpreter should be "
"encoded in UTF-8 on Windows, and in :func:`sys.getfilesystemencoding()` on "
"POSIX."
msgstr ""
"Une ligne *shebang* facultative, contenant les caractères ``b'#!`` suivis "
"d'un nom d’interpréteur, puis un caractère fin de ligne (``b'\\n'``).  Le "
"nom de l'interpréteur peut être n'importe quoi acceptable pour le traitement "
"*shebang* de l'OS, ou le lanceur Python sous Windows.  L'interpréteur doit "
"être encodé en UTF-8 sous Windows, et en :func:`sys.getfilesystemencoding()` "
"sur POSIX."

#: ../Doc/library/zipapp.rst:247
msgid ""
"Standard zipfile data, as generated by the :mod:`zipfile` module.  The "
"zipfile content *must* include a file called ``__main__.py`` (which must be "
"in the \"root\" of the zipfile - i.e., it cannot be in a subdirectory).  The "
"zipfile data can be compressed or uncompressed."
msgstr ""
"Des données *zipfile* standards, telles que générées par le module :mod:"
"`zipfile`.  Le contenu du fichier zip *doit* inclure un fichier appelé "
"``__main__.py`` (qui doit se trouver à la racine du fichier zip — c'est-à-"
"dire qu'il ne peut se trouver dans un sous-répertoire).  Les données du "
"fichier zip peuvent être compressées ou non."

#: ../Doc/library/zipapp.rst:252
msgid ""
"If an application archive has a shebang line, it may have the executable bit "
"set on POSIX systems, to allow it to be executed directly."
msgstr ""
"Si une archive d'application a une ligne *shebang*, elle peut avoir le bit "
"exécutable activé sur les systèmes POSIX, pour lui permettre d'être exécutée "
"directement."

#: ../Doc/library/zipapp.rst:255
msgid ""
"There is no requirement that the tools in this module are used to create "
"application archives - the module is a convenience, but archives in the "
"above format created by any means are acceptable to Python."
msgstr ""
"Vous pouvez créer des archives d'applications sans utiliser les outils de ce "
"module — le module existe pour faciliter les choses, mais les archives, "
"créées par n'importe quel moyen tout en respectant le format ci-dessus, sont "
"valides pour Python."