# SOME DESCRIPTIVE TITLE.
# Copyright (C) Kovid Goyal
# This file is distributed under the same license as the calibre package.
# 
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: calibre\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-02-02 05:59+0000\n"
"PO-Revision-Date: 2014-06-17 08:34+0000\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: French (Canada) (http://www.transifex.com/calibre/calibre/language/fr_CA/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: fr_CA\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % 1000000 == 0 ? 1 : 2;\n"

#: ../../__w/calibre/calibre/manual/template_lang.rst:4
msgid "The calibre template language"
msgstr "Le langage de modèle calibre"

#: ../../__w/calibre/calibre/manual/template_lang.rst:6
msgid ""
"The calibre template language is a calibre-specific language used throughout"
" calibre for tasks such as specifying file paths, formatting values, and "
"computing the value for user-specified columns. Examples:"
msgstr "Le langage de modèle de calibre est un langage spécifique à calibre utilisé dans l'ensemble de calibre pour des tâches telles que la spécification des chemins de fichiers, le formatage des valeurs et le calcul de la valeur des colonnes spécifiées par l'utilisateur. Exemples :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:8
msgid ""
"Specify the folder structure and file names when saving files from the "
"calibre library to the disk or e-book reader."
msgstr "Spécifier la structure du dossier et les noms de fichiers lors de l'enregistrement des fichiers de la bibliothèque calibre sur le disque ou le lecteur de livres numériques."

#: ../../__w/calibre/calibre/manual/template_lang.rst:9
msgid "Define rules for adding icons and colors to the calibre book list."
msgstr "Définir des règles pour l'ajout d'icônes et de couleurs à la liste de livres de calibre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:10
msgid "Define `virtual columns` that contain data from other columns."
msgstr "Définir les `colonnes virtuelles` qui contiennent des données provenant d'autres colonnes."

#: ../../__w/calibre/calibre/manual/template_lang.rst:11
msgid "Advanced library searching."
msgstr "Recherche avancée dans la bibliothèque."

#: ../../__w/calibre/calibre/manual/template_lang.rst:12
msgid "Advanced metadata search and replace."
msgstr "Recherche et remplacement avancé des métadonnées."

#: ../../__w/calibre/calibre/manual/template_lang.rst:14
msgid ""
"The language is built around the notion of a `template`, which specifies "
"which book metadata to use, computations on that metadata, and how it is to "
"be formatted."
msgstr "Le langage est construit autour de la notion de `modèle`, qui spécifie les métadonnées du livre à utiliser, les calculs sur ces métadonnées, et la façon dont elles doivent être formatées."

#: ../../__w/calibre/calibre/manual/template_lang.rst:17
msgid "Basic templates"
msgstr "Modèles de base"

#: ../../__w/calibre/calibre/manual/template_lang.rst:19
msgid ""
"A basic template consists one or more ``template expressions``. A ``template"
" expression`` consists of text and names in curly brackets (``{}``) that is "
"replaced by the corresponding metadata from the book being processed. For "
"example, the default template in calibre used for saving books to device has"
" 4 ``template expressions``::"
msgstr "Un modèle de base est constitué d'une ou plusieurs ``expression modèle``. Une ``expression modèle`` consiste en du texte et des noms entre crochets (``{}``) qui sont remplacés par les métadonnées correspondantes du livre en cours de traitement. Par exemple, le modèle par défaut de calibre utilisé pour enregistrer des livres sur un périphérique comporte 4 ``expressions modèle``::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:23
msgid "For the book \"The Foundation\" by \"Isaac Asimov\" the  will become::"
msgstr "Pour le livre \"The Foundation\" par \"Isaac Asimov\" cela donnera::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:27
msgid ""
"The slashes are not ``template expressions`` because they are in between in "
"``{}``. Such text is left where it appears. For example, if the template "
"is::"
msgstr "Les barres obliques ne sont pas des ``expressions modèle`` car elles se trouvent entre les ``{}``. Un tel texte est laissé là où il apparaît. Par exemple, si le modèle est::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:31
msgid "then for \"The Foundation\" the template produces::"
msgstr "dès lors, pour \"The Foundation\", le modèle produit::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:35
msgid ""
"A ``template expression`` can access all the metadata available in calibre, "
"including custom columns (columns you create yourself), by using a column's "
"``lookup name``. To find the lookup name for a `column` (sometimes called "
"`fields`), hover your mouse over the column header in calibre's book list. "
"Lookup names for custom columns always begin with ``#``. For series type "
"columns there is an additional field named ``#lookup name_index`` that is "
"the series index for that book in the series. For example, if you have a "
"custom series column named ``#myseries``, there will also be a column named "
"``#myseries_index``. The standard series column's index is named "
"``series_index``."
msgstr "Une ``expression modèle`` peut accéder à toutes les métadonnées disponibles dans calibre, y compris les colonnes personnalisées (colonnes que vous créez vous-même), en utilisant le ``nom de recherche`` d'une `colonne`. Pour trouver le nom de recherche d'une `colonne` (parfois appelée `champs`), passez votre souris sur l'en-tête de la colonne dans la liste des livres de calibre. Les noms de recherche pour les colonnes personnalisées commencent toujours par ``#``. Pour les colonnes de type série, il y a un champ supplémentaire appelé ``#lookup name_index`` qui est l'index de la série pour ce livre dans la série. Par exemple, si vous avez une colonne de série personnalisée nommée ``#messéries``, il y aura également une colonne nommée ``#messéries_index``. L'index de la colonne de série standard est nommé ``series_index``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:37
msgid "In addition to the standard column based fields, you also can use:"
msgstr "En plus des champs standard basés sur des colonnes, vous pouvez également utiliser :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:39
msgid ""
"``{formats}`` - A list of formats available in the calibre library for a "
"book"
msgstr "``{formats}`` - Une liste des formats disponibles dans la bibliothèque calibre pour un livre"

#: ../../__w/calibre/calibre/manual/template_lang.rst:40
msgid "``{identifiers:select(isbn)}`` - The ISBN of the book"
msgstr "``{identifiers:select(isbn)}`` - L'ISBN du livre"

#: ../../__w/calibre/calibre/manual/template_lang.rst:42
msgid ""
"If the metadata for the field for a given book is not defined then the field"
" in the template is replaced by the empty string (``''``). For example, "
"consider the following template::"
msgstr "Si les métadonnées du champ pour un livre donné ne sont pas définies, le champ dans le modèle est remplacé par la chaîne vide (``''``). Par exemple, considérons le modèle suivant ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:46
msgid ""
"If Asimov's book \"Second Foundation\" is in the series \"Foundation\" then "
"the template produces::"
msgstr "Si le livre d'Asimov \"Seconde Fondation\" fait partie de la série \"Fondation\", alors le modèle produit ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:50
msgid ""
"If a series has not been entered for the book then the template produces::"
msgstr "Si aucune série n'a été saisie pour le livre, le modèle produit ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:54
msgid ""
"The template processor automatically removes multiple slashes and leading or"
" trailing spaces."
msgstr "Le processeur de modèles supprime automatiquement les barres obliques multiples et les espaces avant ou arrière."

#: ../../__w/calibre/calibre/manual/template_lang.rst:57
msgid "Advanced formatting"
msgstr "Mise en forme avancée"

#: ../../__w/calibre/calibre/manual/template_lang.rst:59
msgid ""
"In addition to metadata substitution, templates can conditionally include "
"additional text and control how substituted data is formatted."
msgstr "Outre la substitution de métadonnées, les modèles peuvent inclure du texte supplémentaire de manière conditionnelle et contrôler le formatage des données substituées."

#: ../../__w/calibre/calibre/manual/template_lang.rst:61
msgid "**Conditionally including text**"
msgstr "**Comprenant conditionnellement le texte**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:63
msgid ""
"Sometimes you want text to appear in the output only if a field is not "
"empty. A common case is ``series`` and ``series_index`` where you want "
"either nothing or the two values separated by a hyphen. calibre handles this"
" case using a special ``template expression`` syntax."
msgstr "Parfois, vous voulez que du texte n'apparaisse dans la sortie que si un champ n'est pas vide. Un cas courant est celui de ``series`` et ``series_index`` où vous voulez soit rien, soit les deux valeurs séparées par un trait d'union. calibre gère ce cas en utilisant une syntaxe spéciale de ``expression modèle``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:65
msgid ""
"For example and using the above Foundation example, assume you want the "
"template to produce `Foundation - 3 - Second Foundation`. This template "
"produces that output:"
msgstr "Par exemple, et en utilisant l'exemple de Fondation ci-dessus, supposons que vous voulez que le modèle produise `Fondation - 3 - Deuxième Fondation`. Ce modèle produit ce résultat :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:67
msgid "``{series} - {series_index} - {title}``"
msgstr "``{series} - {series_index} - {title}``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:69
msgid ""
"However, if a book has no series the template will produce `- - the title`, "
"which is probably not what you want. Generally, people want the result be "
"the title without the extraneous hyphens. You can accomplish this using the "
"following template syntax:"
msgstr "Cependant, si un livre n'a pas de série, le modèle produira `- - le titre`, ce qui n'est probablement pas ce que vous voulez. En général, les gens veulent que le résultat soit le titre sans les traits d'union superflus. Vous pouvez y parvenir en utilisant la syntaxe de modèle suivante :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:71
msgid "``{field:|prefix_text|suffix_text}``"
msgstr "``{field:|prefix_text|suffix_text}``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:73
msgid ""
"This ``template expression`` says that if ``field`` has the value `XXXX` "
"then the result will be `prefix_textXXXXXsuffix_text`. If ``field`` is empty"
" (has no value) then the result will be the empty string (nothing) because "
"the prefix and suffix are ignored. The prefix and suffix can contain blanks."
msgstr "Cette ``expression modèle`` indique que si ``champ`` a la valeur ``XXXX``, le résultat sera ``prefix_textXXXXXsuffix_text``. Si ``champ`` est vide (n'a pas de valeur) alors le résultat sera la chaîne vide (rien) car le préfixe et le suffixe sont ignorés. Le préfixe et le suffixe peuvent contenir des blancs."

#: ../../__w/calibre/calibre/manual/template_lang.rst:75
msgid ""
"**Do not use subtemplates (`{ ... }`) or functions (see below) in the prefix"
" or the suffix.**"
msgstr "**Ne pas utiliser de sous-modèles (`{ ... }`) ou de fonctions (voir ci-dessous) dans le préfixe ou le suffixe.**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:77
msgid ""
"Using this syntax, we can solve the above no-series problem with the "
"template::"
msgstr "En utilisant cette syntaxe, nous pouvons résoudre le problème de non-série ci-dessus avec le modèle ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:81
msgid ""
"The hyphens will be included only if the book has a series index, which it "
"has only if it has a series. Continuing the Foundation example again, the "
"template will produce `Foundation - 1 - Second Foundation`."
msgstr "Les traits d'union ne seront inclus que si le livre possède un index de série, ce qui n'est le cas que si le livre possède une série. Si l'on reprend l'exemple de Fondation, le modèle produira `Fondation - 1 - Deuxième Fondation`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:83
#: ../../__w/calibre/calibre/manual/template_lang.rst:260
msgid "Notes:"
msgstr "Notes :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:85
msgid ""
"You must include the colon after the ``lookup name`` if you are using a "
"prefix or a suffix."
msgstr "Vous devez inclure les deux points après le ``nom de la recherche`` si vous utilisez un préfixe ou un suffixe."

#: ../../__w/calibre/calibre/manual/template_lang.rst:86
msgid ""
"You must either use either no or both ``|`` characters. Using one, as in "
"``{field:| - }``, is not allowed."
msgstr "Vous devez utiliser soit aucun des caractères ``|``, soit les deux. L'utilisation d'un seul caractère, comme dans ``{field:| - }``, n'est pas autorisée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:87
msgid ""
"It is OK to provide no text for either the prefix or the suffix, such as in "
"``{series:|| - }``. The template ``{title:||}`` is the same as ``{title}``."
msgstr "Il est possible de ne fournir aucun texte pour le préfixe ou le suffixe, comme dans ``{série:|| - }``. Le modèle ``{title:||}`` est le même que ``{title}``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:89
msgid "**Formatting**"
msgstr "**Formatage**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:91
msgid ""
"Suppose you want the ``series_index`` to be formatted as three digits with "
"leading zeros. This does the trick:"
msgstr "Supposons que vous vouliez que ``series_index`` soit formaté en trois chiffres avec des zéros en tête. Ceci fait l'affaire :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:93
msgid "``{series_index:0>3s}`` - Three digits with leading zeros"
msgstr "``{series_index:0>3s}`` - Trois chiffres avec des zéros en tête"

#: ../../__w/calibre/calibre/manual/template_lang.rst:95
msgid "For trailing zeros, use:"
msgstr "Pour des zéros qui suivent, utilisez:"

#: ../../__w/calibre/calibre/manual/template_lang.rst:97
msgid "``{series_index:0<3s}`` - Three digits with trailing zeros"
msgstr "``{series_index:0>3s}`` - Trois chiffres avec des zéros qui suivent"

#: ../../__w/calibre/calibre/manual/template_lang.rst:99
msgid ""
"If you use series indices with fractional values, e.g., 1.1, you might want "
"the decimal points to line up. For example, you might want the indices 1 and"
" 2.5 to appear as 01.00 and 02.50 so that they will sort correctly on a "
"device that does lexical sorting. To do this, use:"
msgstr "Si vous utilisez des indices de série avec des valeurs fractionnées, par exemple 1.1, vous pouvez souhaiter que les points décimaux soient alignés. Par exemple, vous pouvez vouloir que les indices 1 et 2.5 apparaissent sous la forme 01.00 et 02.50 afin qu'ils soient triés correctement sur un périphérique qui effectue un tri lexical. Pour ce faire, utilisez :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:101
msgid ""
"``{series_index:0>5.2f}`` - Five characters consisting of two digits with "
"leading zeros, a decimal point, then 2 digits after the decimal point."
msgstr "``{series_index:0>5.2f}`` - Cinq caractères composés de deux chiffres avec des zéros en tête, un point décimal, puis deux chiffres après le point décimal."

#: ../../__w/calibre/calibre/manual/template_lang.rst:103
msgid "If you want only the first two letters of the data, use:"
msgstr "Si vous ne voulez que les deux premières lettres de la donnée, utilisez :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:105
msgid ""
"``{author_sort:.2}`` - Only the first two letters of the author sort name"
msgstr "``{author_sort :.2}`` - Seulement les deux premières lettres du nom de tri de l'auteur"

#: ../../__w/calibre/calibre/manual/template_lang.rst:107
msgid ""
"Much of the calibre template language formatting comes from Python. For more"
" details on the syntax of these advanced formatting operations see the "
"`Python documentation "
"<https://docs.python.org/3/library/string.html#formatstrings>`_."
msgstr "Une grande partie du formatage du langage de modèle de calibre provient de Python. Pour plus de détails sur la syntaxe de ces opérations de formatage avancées, voir la `documentation Python <https://docs.python.org/3/library/string.html#formatstrings>`"

#: ../../__w/calibre/calibre/manual/template_lang.rst:111
msgid "Using templates to define custom columns"
msgstr "Utilisation de modèles pour définir des colonnes personnalisées"

#: ../../__w/calibre/calibre/manual/template_lang.rst:113
msgid ""
"Templates can be used to display information that isn't in calibre metadata,"
" or to display metadata differently from calibre's normal format. For "
"example, you might want to show the ``ISBN``, a field that calibre does not "
"display. You can accomplish this creating a custom column with the type "
"`Column built from other columns` (hereafter called `composite columns`) and"
" providing a template to generate the displayed text. The column will "
"display the result of evaluating the template. For example, to display the "
"ISBN, create the column and enter ``{identifiers:select(isbn)}`` in the "
"template box. To display a column containing the values of two series custom"
" columns, separated by a comma, use ``{#series1:||,}{#series2}``."
msgstr "Les modèles peuvent être utilisés pour afficher des informations qui ne sont pas dans les métadonnées de calibre, ou pour afficher les métadonnées différemment du format normal de calibre. Par exemple, vous pourriez vouloir afficher le ``ISBN``, un champ que calibre n'affiche pas. Pour cela, vous pouvez créer une colonne personnalisée de type `Colonne construite à partir d'autres colonnes` (appelée ci-après `colonnes composites`) et fournir un modèle pour générer le texte affiché. La colonne affichera le résultat de l'évaluation du modèle. Par exemple, pour afficher l'ISBN, créez la colonne et entrez \"identifiers:select(isbn)}\" dans la champ du modèle. Pour afficher une colonne contenant les valeurs de deux colonnes personnalisées de séries, séparées par une virgule, utilisez ``{#series1:||,}{#series2}``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:115
msgid "Composite columns can use any template option, including formatting."
msgstr "Les colonnes composites peuvent utiliser n'importe quelle option modèle, y compris le formatage."

#: ../../__w/calibre/calibre/manual/template_lang.rst:117
msgid ""
"Note: You cannot edit the data displayed in a composite column. Instead you "
"edit the source columns. If you edit a composite column, for example by "
"double-clicking it, calibre will open the template for editing, not the "
"underlying data."
msgstr "Remarque : Vous ne pouvez pas modifier les données affichées dans une colonne composite. Vous devez plutôt modifier les colonnes sources. Si vous modifiez une colonne composite, par exemple en double-cliquant dessus, calibre ouvrira le modèle à modifier, et non les données sous-jacentes."

#: ../../__w/calibre/calibre/manual/template_lang.rst:122
msgid "Using functions in templates - Single Function Mode"
msgstr "Utilisation des fonctions dans les modèles - Mode de fonctionnement unique"

#: ../../__w/calibre/calibre/manual/template_lang.rst:124
msgid ""
"Suppose you want to display the value of a field in upper case when that "
"field is normally in title case. You can do this using `template functions`."
" For example, to display the title in upper case use the ``uppercase`` "
"function, as in ``{title:uppercase()}``. To display it in title case, use "
"``{title:titlecase()}``."
msgstr "Supposons que vous vouliez afficher la valeur d'un champ en casse majuscules alors que ce champ est normalement en casse titre. Vous pouvez le faire en utilisant les fonctions de modèle. Par exemple, pour afficher le titre en casse majuscules, utilisez la fonction ``uppercase``, comme dans ``{title:uppercase()}``. Pour l'afficher en casse titre, utilisez la fonction ``{title:titlecase()}``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:126
msgid ""
"Functions go into the format part of the template, after the ``:`` and "
"before the first ``|`` or the closing ``}`` if no prefix/suffix is used. If "
"you have both a format and a function reference, the function comes after a "
"second ``:``.  Functions return the value of the column specified in the "
"template, suitably modified."
msgstr "Les fonctions sont placées dans la partie format du modèle, après le ``:`` et avant le premier ``|`` ou le ``}`` de fermeture si aucun préfixe/suffixe n'est utilisé. Si vous avez à la fois une référence de format et de fonction, la fonction vient après un deuxième ``:``. Les fonctions renvoient la valeur de la colonne spécifiée dans le modèle, convenablement modifiée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:128
msgid "The syntax for using functions is one of::"
msgstr "La syntaxe pour utiliser les fonctions est l'une des suivantes ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:135
msgid ""
"Function names must always be followed by opening and closing parentheses. "
"Some functions require extra values (arguments), and these go inside the "
"parentheses. Arguments are separated by commas. Literal commas (commas as "
"text, not argument separators) must be preceded by a backslash (``\\``) . "
"The last (or only) argument cannot contain a textual closing parenthesis."
msgstr "Les noms de fonctions doivent toujours être suivis de parenthèses ouvrantes et fermantes. Certaines fonctions nécessitent des valeurs supplémentaires (arguments), qui sont placées à l'intérieur des parenthèses. Les arguments sont séparés par des virgules. Les virgules Littérales (les virgules en tant que texte, et non en tant que séparateurs d'arguments) doivent être précédées d'une barre oblique inversée (``\\``) . Le dernier (ou le seul) argument ne peut pas contenir de parenthèse fermante textuelle."

#: ../../__w/calibre/calibre/manual/template_lang.rst:137
msgid ""
"Functions are evaluated before format specifications and the prefix/suffix. "
"See further down for an example of using both a format and a function."
msgstr "Les fonctions sont évaluées avant les spécifications de format et le préfixe/suffixe. Voir plus bas pour un exemple d'utilisation à la fois d'un format et d'une fonction."

#: ../../__w/calibre/calibre/manual/template_lang.rst:139
msgid ""
"**Important**: If you have programming experience, please note that the "
"syntax in `Single Function Mode` is not what you expect. Strings are not "
"quoted and spaces are significant. All arguments are considered to be "
"constants; there are no expressions."
msgstr "**Important** : Si vous avez de l'expérience en programmation, veuillez noter que la syntaxe du `Mode Fonction Unique` n'est pas celle à laquelle vous vous attendez. Les chaînes de caractères ne sont pas citées et les espaces sont significatifs. Tous les arguments sont considérés comme des constantes ; il n'y a pas d'expressions."

#: ../../__w/calibre/calibre/manual/template_lang.rst:141
msgid ""
"**Do not use subtemplates (`{ ... }`) as function arguments.** Instead, use "
":ref:`Template Program Mode <template_mode>` and :ref:`General Program Mode "
"<general_mode>`."
msgstr "**N'utilisez pas les sous-modèles (`{ ... }`) comme arguments de fonction.** A la place, utilisez plutôt :ref:`Mode Programme Modèle` et :ref:`Mode Programme Général`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:143
msgid ""
"Some functions require regular expressions. In the template language regular"
" expression matching is case-insensitive."
msgstr "Certaines fonctions nécessitent des expressions régulières. Dans le langage des modèles, la correspondance des expressions régulières est insensible à la casse."

#: ../../__w/calibre/calibre/manual/template_lang.rst:145
msgid ""
"In the function documentation below, the notation ``[something]*`` means "
"that ``something`` can be repeated zero or more times. The notation "
"``[something]+`` means that the ``something`` is repeated one or more times "
"(must exist at least one time)."
msgstr "Dans la documentation des fonctions ci-dessous, la notation ``[quelque chose]*`` signifie que ``quelque chose`` peut être répété zéro fois ou plus. La notation ``[quelque chose]+`` signifie que ``quelque chose`` est répété une ou plusieurs fois (doit exister au moins une fois)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:147
msgid "The functions intended for use in Single Function Mode are:"
msgstr "Les fonctions destinées à être utilisées en Mode Fonction Unique sont les suivantes :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:150
msgid ""
"``capitalize()`` -- returns the value with the first letter upper case and "
"the rest lower case."
msgstr "``capitalize()``  -- renvoie la valeur avec la première lettre en majuscule et le reste en minuscule."

#: ../../__w/calibre/calibre/manual/template_lang.rst:151
msgid ""
"``contains(pattern, text if match, text if not match)`` -- checks if the "
"value is matched by the regular expression ``pattern``. Returns ``text if "
"match`` if the pattern matches the value, otherwise returns ``text if no "
"match``."
msgstr "``contains(pattern, text if match, text if not match)`` -- vérifie si la valeur est couverte par l'expression régulière ``pattern``. Renvoie ``text if match`` si le motif correspond à la valeur, sinon renvoie ``text if no match``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:152
msgid ""
"``count(separator)`` -- interprets the value as a list of items separated by"
" ``separator`` and returns the number of items in the list. Most lists use a"
" comma as the separator, but ``authors`` uses an ampersand (&). Examples: "
"``{tags:count(,)}``, ``{authors:count(&)}``. Aliases: ``count()``, "
"``list_count()``"
msgstr "``count(separator)`` -- interprète la valeur comme une liste d'éléments séparés par le ``separator`` et retourne le nombre d'éléments dans la liste. La plupart des listes utilisent une virgule comme séparateur, mais ``authors`` utilise une esperluette (&). Exemples : ``{tags:count(,)}``, ``{authors:count(&)}``. Alias : ``count()``, ``list_count()``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:153
msgid ""
"``format_number(template)`` -- interprets the value as a number and formats "
"that number using a Python formatting template such as ``{0:5.2f}`` or "
"``{0:,d}`` or ``${0:5,.2f}``. The formatting template must begin with "
"``{0:`` and end with ``}`` as in the above examples. Exception: you can "
"leave off the leading \"{0:\" and trailing \"}\" if the format template "
"contains only a format. See the template language and the `Python "
"documentation "
"<https://docs.python.org/3/library/string.html#formatstrings>`_ for more "
"examples. Returns the empty string if formatting fails."
msgstr "``format_number(template)`` -- interprète la valeur comme un nombre et formate ce nombre en utilisant un modèle de formatage Python tel que ``{0:5.2f}`` ou `{0 :,d}`` ou ``${0:5,.2f}``. Le modèle de formatage doit commencer par ``{0:`` et se terminer par ``}`` comme dans les exemples ci-dessus. Exception : vous pouvez omettre le début \"{0 :\" et la fin \"}\" si le modèle de format ne contient qu'un format. Voir le langage des modèles et la documentation `Python <https://docs.python.org/3/library/string.html#formatstrings>`_ pour plus d'exemples. Renvoie la chaîne vide si le formatage échoue."

#: ../../__w/calibre/calibre/manual/template_lang.rst:154
msgid ""
"``human_readable()`` -- expects the value to be a number and returns a "
"string representing that number in KB, MB, GB, etc."
msgstr "``human_readable()`` -- s'attend que la valeur soit un nombre et renvoie une chaîne représentant ce nombre en KB, MB, GB, etc."

#: ../../__w/calibre/calibre/manual/template_lang.rst:155
msgid ""
"``ifempty(text if empty)`` -- if the value is not empty then return the "
"value of the field, otherwise return `text if empty`."
msgstr "``ifempty(text)`` -- si le champ n'est pas vide, renvoie la valeur du champ. Autrement renvoie `text if empty`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:156
msgid ""
"``in_list(separator, [ pattern, found_val, ]* not_found_val)`` -- interpret "
"the value as a list of items separated by ``separator``, checking the "
"``pattern`` against each item in the list. If the ``pattern`` matches an "
"item then return ``found_val``, otherwise return ``not_found_val``. The pair"
" ``pattern`` and ``found_value`` can be repeated as many times as desired, "
"permitting returning different values depending on the item's value. The "
"patterns are checked in order, and the first match is returned."
msgstr "``in_list(separator, [ pattern, found_val, ]* not_found_val)`` -- interprète la valeur comme une liste d'éléments séparés par le ``separator``, en vérifiant le ``pattern`` pour chaque élément de la liste. Si le ``pattern`` correspond à un élément, il renvoie ``found_val``, sinon il renvoie ``not_found_val``. La paire ``pattern``et ``found_value`` peut être répétée autant de fois que souhaité, ce qui permet de renvoyer des valeurs différentes selon la valeur de l'élément. Les motifs sont vérifiés dans l'ordre, et la première correspondance est retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:157
msgid ""
"``language_strings(localize)`` -- return the `language names "
"<https://www.loc.gov/standards/iso639-2/php/code_list.php>`_ for the "
"`language codes <https://www.loc.gov/standards/iso639-2/php/code_list.php>`_"
" passed in as the value. Example: ``{languages:language_strings()}``.  If "
"``localize`` is zero, return the strings in English. If ``localize`` is not "
"zero, return the strings in the language of the current locale. "
"``Lang_codes`` is a comma-separated list."
msgstr "``language_strings(localize)`` -- retourne les `noms de langue <https://www.loc.gov/standards/iso639-2/php/code_list.php>`_ pour les `codes de langue <https://www.loc.gov/standards/iso639-2/php/code_list.php>`_ passés en tant que valeur. Exemple : ``{languages:language_strings()}``. Si ``localize`` est zéro, retourne les chaînes de caractères en anglais. Si ``localize`` est différent de zéro, retourne les chaînes de caractères dans la langue de la locale courante. ``Lang_codes`` est une liste séparée par des virgules."

#: ../../__w/calibre/calibre/manual/template_lang.rst:158
msgid ""
"``list_item(index, separator)`` -- interpret the value as a list of items "
"separated by ``separator``, returning the 'index'th item. The first item is "
"number zero. The last item has the index ``-1`` as in "
"``list_item(-1,separator)``. If the item is not in the list, then the empty "
"string is returned."
msgstr "``list_item(index, separator)`` -- interprète la valeur comme une liste d'éléments séparés par un ``separator``, en retournant ``index'``. Le premier élément est le numéro zéro. Le dernier élément a l'indice ``-1`` comme dans ``list_item(-1,separator)``. Si l'élément n'est pas dans la liste, alors la chaîne vide est retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:159
msgid ""
"``lookup([ pattern, key, ]* else_key)`` -- The patterns will be checked "
"against the value in order. If a pattern matches then the value of the field"
" named by ``key`` is returned. If no pattern matches then the value of the "
"field named by ``else_key`` is returned. See``switch`` (below)."
msgstr "``lookup([ pattern, key, ]* else_key)`` -- Les motifs seront comparés à la valeur dans l'ordre. Si un motif correspond, la valeur du champ nommé par ``key`` est retournée. Si aucun motif ne correspond, la valeur du champ nommé par ``else_key`` est retournée. Voir ``switch`` (ci-dessous)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:160
msgid "``lowercase()`` -- returns the value of the field in lower case."
msgstr "``lowercase()`` -- renvoie la valeur du champ en minuscule."

#: ../../__w/calibre/calibre/manual/template_lang.rst:161
msgid ""
"``rating_to_stars(use_half_stars)`` -- Returns the rating as string of star "
"(``★``) characters. The value must be a number between 0 and 5. Set "
"use_half_stars to 1 if you want half star characters for fractional numbers "
"available with custom ratings columns."
msgstr "``rating_to_stars(use_half_stars)`` -- Renvoie la note sous forme de chaîne de caractères étoilés (``★``). La valeur doit être un nombre entre 0 et 5. Définissez use_half_stars à 1 si vous voulez des caractères de demi-étoile pour les nombres fractionnés disponibles avec les colonnes d'évaluation personnalisées."

#: ../../__w/calibre/calibre/manual/template_lang.rst:162
msgid ""
"``re(pattern, replacement)`` -- return the value after applying the regular "
"expression. All instances of ``pattern`` in the value are replaced with "
"``replacement``. The template language uses case insensitive `Python regular"
" expressions <https://docs.python.org/3/library/re.html>`_."
msgstr "``re(pattern, replacement)`` -- retourne la valeur après application de l'expression régulière. Toutes les instances de ``pattern`` dans la valeur sont remplacées par ``replacement``. Le langage des modèles utilise des `Expressions régulières Python <https://docs.python.org/3/library/re.html>`_ insensibles à la casse."

#: ../../__w/calibre/calibre/manual/template_lang.rst:163
msgid ""
"``select(key)`` -- interpret the value as a comma-separated list of items "
"with each item having the form ``id:value`` (the calibre ``identifier`` "
"format). The function finds the first pair with the id equal to key and "
"returns the corresponding value. If no id matches then the function returns "
"the empty string."
msgstr "``select(key)`` -- interprète la valeur comme une liste d'éléments séparés par des virgules, chaque élément ayant la forme ``id:value`` (le format ``identifiant`` de calibre). La fonction trouve la première paire dont l'id est égal à key et renvoie la valeur correspondante. Si aucun id ne correspond, la fonction renvoie la chaîne vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:164
msgid ""
"``shorten(left chars, middle text, right chars)`` -- Return a shortened "
"version of the value, consisting of ``left chars`` characters from the "
"beginning of the value, followed by ``middle text``, followed by ``right "
"chars`` characters from the end of the value. ``Left chars`` and ``right "
"chars`` must be non-negative integers. Example: assume you want to display "
"the title with a length of at most 15 characters in length. One template "
"that does this is ``{title:shorten(9,-,5)}``. For a book with the title "
"`Ancient English Laws in the Times of Ivanhoe` the result will be `Ancient "
"E-anhoe`: the first 9 characters of the title, a ``-``, then the last 5 "
"characters. If the value's length is less than ``left chars`` + ``right "
"chars`` + the length of ``middle text`` then the value will be returned "
"unchanged. For example, the title `The Dome` would not be changed."
msgstr "``shorten(left chars, middle text, right chars)`` -- Renvoie une version raccourcie de la valeur, composée de ``left chars`` du début de la valeur, suivis de ``middle text``, suivis de ``right chars`` de la fin de la valeur. Les \"left chars\" et les \"right chars\" doivent être des entiers non négatifs. Exemple : supposons que vous vouliez afficher le titre avec une longueur maximale de 15 caractères. Un modèle qui fait cela est ``{titre:shorten(9,-,5)}``. Pour un livre dont le titre est `Ancient English Laws in the Times of Ivanhoe`, le résultat sera `Ancient E-anhoe` : les 9 premiers caractères du titre, un ``-``, puis les 5 derniers caractères. Si la longueur de la valeur est inférieure à ``left chars`` + ``right chars`` + la longueur du ``middle text`` alors la valeur sera retournée inchangée. Par exemple, le titre `Le Dôme` ne sera pas modifié."

#: ../../__w/calibre/calibre/manual/template_lang.rst:165
msgid ""
"``str_in_list(separator, [ string, found_val, ]+ not_found_val)`` -- "
"interpret the value as a list of items separated by ``separator`` then "
"compare ``string`` against each value in the list. The ``string`` is not a "
"regular expression. If ``string`` is equal to any item (ignoring case) then "
"return the corresponding ``found_val``. If ``string`` contains "
"``separators`` then it is also treated as a list and each subvalue is "
"checked. The ``string`` and ``found_value`` pairs can be repeated as many "
"times as desired, permitting returning different values depending on "
"string's value. If none of the strings match then ``not_found_value`` is "
"returned. The strings are checked in order. The first match is returned."
msgstr "``str_in_list(separator, [ string, found_val, ]+ not_found_val)`` -- interprète la valeur comme une liste d'éléments séparés par le ``separator`` puis compare ``string`` à chaque valeur de la liste. ``string`` n'est pas une expression régulière. Si ``string`` est égal à n'importe quel élément (en ignorant la casse), alors il renvoie la ``found_val`` correspondante. Si ``string`` contient des ``separators``, elle est également traitée comme une liste et chaque sous-valeur est vérifiée. Les paires ``string`` et ``found_value`` peuvent être répétées autant de fois que souhaité, ce qui permet de renvoyer des valeurs différentes selon la valeur de la chaîne. Si aucune des chaînes de caractères ne correspond, le système renvoie ``not_found_value``. Les chaînes de caractères sont vérifiées dans l'ordre. La première correspondance est retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:166
msgid ""
"``subitems(start_index, end_index)`` -- This function breaks apart lists of "
"tag-like hierarchical items such as genres. It interprets the value as a "
"comma-separated list of tag-like items, where each item is a period-"
"separated list. It returns a new list made by extracting from each item the "
"components from ``start_index`` to ``end_index``, then merging the results "
"back together. Duplicates are removed. The first subitem in a period-"
"separated list has an index of zero. If an index is negative then it counts "
"from the end of the list. As a special case, an end_index of zero is assumed"
" to be the length of the list."
msgstr "``subitems(start_index, end_index)`` -- Cette fonction sépare les listes d'éléments hiérarchiques de type balise, comme les genres. Elle interprète la valeur comme une liste d'éléments de type balise séparés par des virgules, où chaque élément est une liste séparée par des points. Elle retourne une nouvelle liste faite en extrayant de chaque élément les composants de ``start_index`` à ``end_index``, puis en fusionnant les résultats ensemble. Les doublons sont supprimés. Le premier sous-élément d'une liste séparée par un point a un indice de zéro. Si un index est négatif, il est compté à partir de la fin de la liste. Dans un cas particulier, un end_index de zéro est supposé être la longueur de la liste."

#: ../../__w/calibre/calibre/manual/template_lang.rst:168
#: ../../__w/calibre/calibre/manual/template_lang.rst:388
msgid "Examples:"
msgstr "Exemples : "

#: ../../__w/calibre/calibre/manual/template_lang.rst:170
msgid "Assuming a #genre column containing `A.B.C`:"
msgstr "Supposons une colonne #genre contenant `A.B.C` :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:172
msgid "``{#genre:subitems(0,1)}`` returns \"A\""
msgstr "``{#genre:subitems(0,1)}`` renvoie \"A\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:173
msgid "``{#genre:subitems(0,2)}`` returns \"A.B\""
msgstr "``{#genre:subitems(0,2)}`` renvoie \"A.B\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:174
msgid "``{#genre:subitems(1,0)}`` returns \"B.C\""
msgstr "``{#genre:subitems(1,0)}`` renvoie \"B.C\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:176
msgid "Assuming a #genre column containing \"A.B.C, D.E\":"
msgstr "Supposons une colonne #genre contenant \"A.B.C, D.E\" :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:178
msgid "``{#genre:subitems(0,1)}`` returns \"A, D\""
msgstr "``{#genre:subitems(0,1)}`` renvoie \"A, D\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:179
msgid "``{#genre:subitems(0,2)}`` returns \"A.B, D.E\""
msgstr "``{#genre:subitems(0,2)}`` renvoie \"A.B, D.E\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:181
msgid ""
"``sublist(start_index, end_index, separator)`` -- interpret the value as a "
"list of items separated by ``separator``, returning a new list made from the"
" items from ``start_index`` to ``end_index``. The first item is number zero."
" If an index is negative, then it counts from the end of the list. As a "
"special case, an end_index of zero is assumed to be the length of the list."
msgstr "``sublist(start_index, end_index, separator)`` -- interprète la valeur comme une liste d'éléments séparés par le ``separator``, renvoyant une nouvelle liste composée des éléments de ``start_index`` à ``end_index``. Le premier élément est le numéro zéro. Si un index est négatif, alors il compte à partir de la fin de la liste. Dans un cas spécial, un end_index de zéro est supposé être la longueur de la liste."

#: ../../__w/calibre/calibre/manual/template_lang.rst:183
msgid ""
"Examples assuming that the tags column (which is comma-separated) contains "
"\"A, B ,C\":"
msgstr "Exemples en supposant que la colonne des étiquettes (qui est séparée par des virgules) contient \"A, B ,C\" :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:185
msgid "``{tags:sublist(0,1,\\,)}`` returns \"A\""
msgstr "``{tags:sublist(0,1,\\,)}`` renvoie \"A\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:186
msgid "``{tags:sublist(-1,0,\\,)}`` returns \"C\""
msgstr "``{tags:sublist(-1,0,\\,)}`` renvoie \"C\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:187
msgid "``{tags:sublist(0,-1,\\,)}`` returns \"A, B\""
msgstr "``{tags:sublist(0,-1,\\,)}`` renvoie \"A, B\""

#: ../../__w/calibre/calibre/manual/template_lang.rst:189
msgid ""
"``swap_around_articles(separator)`` -- returns the value with articles moved"
" to the end. The value can be a list, in which case each item in the list is"
" processed. If the value is a list then you must provide the ``separator``. "
"If no ``separator`` is provided then the value is treated as being a single "
"value, not a list. The `articles` are those used by calibre to generate the "
"``title_sort``."
msgstr "``swap_around_articles(separator)`` -- renvoie la valeur avec les articles déplacés à la fin. La valeur peut être une liste, dans ce cas chaque article de la liste est traité. Si la valeur est une liste, vous devez fournir le ``séparateur``. Si aucun ``séparateur`` n'est fourni, alors la valeur est traitée comme étant une valeur unique, et non une liste. Les `articles` sont ceux utilisés par calibre pour générer le ``title_sort``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:190
msgid ""
"``swap_around_comma()`` -- given a value of the form ``B, A``, return ``A "
"B``. This is most useful for converting names in LN, FN format to FN LN. If "
"there is no comma in the value then the function returns the value "
"unchanged."
msgstr "``swap_around_comma()`` -- étant donné une valeur de la forme ``B, A``, retourne ``A B``. Ceci est très utile pour convertir des noms au format LN, FN en FN LN. S'il n'y a pas de virgule dans la valeur, la fonction retourne la valeur inchangée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:191
msgid ""
"``switch([pattern, value,]+ else_value)`` -- for each ``pattern, value`` "
"pair, checks if the value matches the regular expression ``pattern`` and if "
"so returns the associated ``value``. If no ``pattern`` matches, then "
"``else_value`` is returned. You can have as many ``pattern, value`` pairs as"
" you wish. The first match is returned."
msgstr "``switch([pattern, value,]+ else_value)`` -- pour chaque paire ``pattern, value``, vérifie si la valeur correspond à l'expression régulière ``pattern`` et si oui, retourne la ``value`` associée. Si aucun ``pattern`` ne correspond, ``else_value`` est retourné. Vous pouvez avoir autant de couples ``pattern, value`` que vous le souhaitez. La première correspondance est retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:192
msgid ""
"``test(text if not empty, text if empty)`` -- return ``text if not empty`` "
"if the value is not empty, otherwise return ``text if empty``."
msgstr "``test(text if not empty, text if empty)`` -- retourne ``text if not empty`` si la valeur n'est pas vide, sinon retourne ``text if empty``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:193
msgid "``titlecase()`` -- returns the value of the field in title case."
msgstr "``titlecase()`` -- renvoie la valeur du champ en casse titre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:194
msgid ""
"``transliterate()`` -- Return a string in a latin alphabet formed by "
"approximating the sound of the words in the source field. For example, if "
"the source field is ``Фёдор Миха́йлович Достоевский`` this function returns "
"``Fiodor Mikhailovich Dostoievskii``."
msgstr "``transliterate()`` - Restitue une chaîne en alphabet latin représentant approximativement le son des mots de la chaîne source. Par exemple,  si le champ source est ``Фёдор Миха́йлович Достоевский`` la fonction renverra ``Fiodor Mikhailovich Dostoievskii``.'"

#: ../../__w/calibre/calibre/manual/template_lang.rst:195
msgid "``uppercase()`` -- returns the value of the field in upper case."
msgstr "``uppercase()`` -- renvoie la valeur du champ en majuscule."

#: ../../__w/calibre/calibre/manual/template_lang.rst:197
msgid "**Using functions and formatting in the same template**"
msgstr "**Utilisation des fonctions et du formatage dans le même modèle**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:199
msgid ""
"Suppose you have an integer custom column ``#myint`` that you want displayed"
" with leading zeros, as in ``003``. One way to do this is to use a format of"
" ``0>3s``. However, by default if a number (integer or float) equals zero "
"then the value is displayed as the empty string so zero values will produce "
"the empty string, not ``000``. If you want to see ``000`` values then you "
"use both the format string and the ``ifempty`` function to change the empty "
"value back to a zero. The template would be::"
msgstr "Supposons que vous ayez une colonne personnalisée de nombres entiers, ``##myint``, que vous voulez afficher avec des zéros en tête, comme dans ``003``. Une façon de le faire est d'utiliser le format ``0>3s``. Cependant, par défaut, si un nombre (entier ou flottant) est égal à zéro, la valeur est affichée sous la forme d'une chaîne vide, de sorte que les valeurs nulles produiront la chaîne vide, et non ``000``. Si vous voulez voir les valeurs ``000``, vous devez utiliser à la fois la chaîne de format et la fonction ``ifempty`` pour transformer la valeur vide en zéro. Le modèle serait ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:203
msgid ""
"Note that you can use the prefix and suffix as well. If you want the number "
"to appear as ``[003]`` or ``[000]``, then use the template::"
msgstr "Notez que vous pouvez également utiliser le préfixe et le suffixe. Si vous voulez que le numéro apparaisse sous la forme ``[003]`` ou ``[000]``, utilisez alors le modèle ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:210
msgid "General Program Mode"
msgstr "Mode Programme Général"

#: ../../__w/calibre/calibre/manual/template_lang.rst:212
msgid ""
"`General Program Mode` (`GPM`) replaces `template expressions` with a "
"program written in the `template language`. The syntax of the language is "
"defined by the following grammar::"
msgstr "Le `Mode Programme Général` (`MPG`) remplace les `expressions modèles` par un programme écrit dans le `langage modèle`. La syntaxe de ce langage est définie par la grammaire suivante ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:262
msgid ""
"a ``top_expression`` always has a value. The value of an ``expression_list``"
" is the value of the last ``top_expression`` in the list. For example, the "
"value of the expression list ``1;2;'foobar';3`` is ``3``."
msgstr "une ``top_expression`` a toujours une valeur. La valeur d'une ``expression_list`` est la valeur de la dernière ``top_expression`` Par exemple, la valeur de la liste d'expressions ``1;2;'foobar';3`` est ``3``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:263
msgid "In a logical context, any non-empty value is ``True``"
msgstr "Dans un contexte logique, toute valeur non vide est ``True``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:264
msgid "In a logical context, the empty value is ``False``"
msgstr "Dans un contexte logique, la valeur vide est ``False``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:265
msgid ""
"Strings and numbers can be used interchangeably. For example, ``10`` and "
"``'10'`` are the same thing."
msgstr "Les chaînes de caractères et les nombres peuvent être utilisés indifféremment. Par exemple, ``10`` et ``'10'`` sont la même chose."

#: ../../__w/calibre/calibre/manual/template_lang.rst:266
msgid ""
"Comments are lines starting with a '#' character. Comments beginning later "
"in a line are not supported."
msgstr "Les commentaires sont des lignes commençant par le caractère \"#\". Les commentaires commençant plus loin dans une ligne ne sont pas pris en charge."

#: ../../__w/calibre/calibre/manual/template_lang.rst:268
msgid "**Operator precedence**"
msgstr "**Préséance de l'opérateur**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:270
msgid ""
"The operator precedence (order of evaluation) from highest (evaluated first)"
" to lowest (evaluated last) is:"
msgstr "L'ordre de préséance de l'opérateurs (ordre d'évaluation), du plus élevé (évalué en premier) au plus bas (évalué en dernier), est le suivant :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:272
msgid ""
"Function calls, constants, parenthesized expressions, statement expressions,"
" assignment expressions, field references."
msgstr "Appels de fonctions, constantes, expressions entre parenthèses, expressions d'instructions, expressions d'affectation, références de champs."

#: ../../__w/calibre/calibre/manual/template_lang.rst:273
msgid ""
"Unary plus (``+``) and minus (``-``). These operators evaluate right to "
"left."
msgstr "Les opérateurs unaires plus (``+``) et moins (``-``). Ces opérateurs s'évaluent de droite à gauche."

#: ../../__w/calibre/calibre/manual/template_lang.rst:275
msgid ""
"These and all the other arithmetic operators return integers if the "
"expression results in a fractional part equal to zero. For example, if an "
"expression returns ``3.0`` it is changed to ``3``."
msgstr "Ces opérateurs et tous les autres opérateurs arithmétiques renvoient des entiers si l'expression donne une partie fractionnaire égale à zéro. Par exemple, si une expression renvoie ``3.0``, elle est transformée en ``3``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:276
msgid ""
"Multiply (``*``) and divide (``/``). These operators are associative and "
"evaluate left to right. Use parentheses if you want to change the order of "
"evaluation."
msgstr "Multiplier (``*``) et diviser (``/``). Ces opérateurs sont associatifs et s'évaluent de gauche à droite. Utilisez les parenthèses si vous souhaitez modifier l'ordre d'évaluation."

#: ../../__w/calibre/calibre/manual/template_lang.rst:277
msgid ""
"Add (``+``) and subtract (``-``). These operators are associative and "
"evaluate left to right."
msgstr "Additionner (``+``) et soustraire (``-``). Ces opérateurs sont associatifs et s'évaluent de gauche à droite."

#: ../../__w/calibre/calibre/manual/template_lang.rst:278
msgid ""
"Numeric and string comparisons. These operators return ``'1'`` if the "
"comparison succeeds, otherwise the empty string (``''``). Comparisons are "
"not associative: ``a < b < c`` is a syntax error."
msgstr "Comparaisons de nombres et de chaînes de caractères. Ces opérateurs renvoient ``'1'`` si la comparaison réussit, sinon la chaîne vide (``''``). Les comparaisons ne sont pas associatives : ``a < b < c`` est une erreur de syntaxe."

#: ../../__w/calibre/calibre/manual/template_lang.rst:279
msgid ""
"String concatenation (``&``). The ``&`` operator returns a string formed by "
"concatenating the left-hand and right-hand expressions. Example: ``'aaa' & "
"'bbb'`` returns ``'aaabbb'``. The operator is associative and evaluates left"
" to right."
msgstr "Concaténation de chaînes de caractères (``&``). L'opérateur ``&`` renvoie une chaîne de caractères formée par la concaténation des expressions de gauche et de droite. Exemple : \" 'aaa' & 'bbb'`` renvoie \" 'aaabbb'``. L'opérateur est associatif et s'évalue de gauche à droite."

#: ../../__w/calibre/calibre/manual/template_lang.rst:280
msgid ""
"Unary logical not (``!``). This operator returns ``'1'`` if the expression "
"is False (evaluates to the empty string), otherwise ``''``."
msgstr "Unaire non logique (``!``). Cet opérateur renvoie ``'1'`` si l'expression est fausse (évaluée à la chaîne vide), sinon ``''``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:281
msgid ""
"Logical and (``&&``). This operator returns '1' if both the left-hand and "
"right-hand expressions are True, or the empty string ``''`` if either is "
"False. It is associative, evaluates left to right, and does `short-"
"circuiting <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_."
msgstr "L'opérateur logique et (``&&``). Cet opérateur renvoie '1' si les deux expressions de gauche et de droite sont vraies, ou la chaîne vide ``''`` si l'une ou l'autre est fausse. Il est associatif, s'évalue de gauche à droite, et fait du `court-circuitage <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_."

#: ../../__w/calibre/calibre/manual/template_lang.rst:282
msgid ""
"Logical or (``||``). This operator returns ``'1'`` if either the left-hand "
"or right-hand expression is True, or ``''`` if both are False. It is "
"associative, evaluates left to right, and does `short-circuiting "
"<https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_. It is an "
"`inclusive or`, returning ``'1'`` if both the left- and right-hand "
"expressions are True."
msgstr "Logique ou (``||``). Cet opérateur renvoie ``'1'`` si l'expression de gauche ou de droite est vraie, ou ``''`` si les deux sont fausses. Il est associatif, s'évalue de gauche à droite, et fait du `court-circuitage <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_. C'est un `or inclusif`, qui renvoie \"1\" si les deux expressions de gauche et de droite sont vraies."

#: ../../__w/calibre/calibre/manual/template_lang.rst:284
msgid "**Field references**"
msgstr "**Références des champs**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:286
msgid ""
"A ``field_reference`` evaluates to the value of the metadata field named by "
"lookup name that follows the ``$`` or ``$$``. Using ``$`` is equivalent to "
"using the ``field()`` function. Using ``$$`` is equivalent to using the "
"``raw_field`` function. Examples::"
msgstr "Un \"field_reference\" est évalué à la valeur du champ de métadonnées nommé par le nom de la consultation qui suit le \"$\" ou le \"$$\". L'utilisation de ``$`` équivaut à l'utilisation de la fonction ``field()``. L'utilisation de ``$$`` équivaut à l'utilisation de la fonction ``raw_field``. Exemples ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:293
msgid "**If expressions**"
msgstr "**Expressions if**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:295
msgid ""
"``If`` expressions first evaluate the ``condition``. If the ``condition`` is"
" True (a non-empty value) then the ``expression_list`` in the ``then`` "
"clause is evaluated. If it is False then if present the ``expression_list`` "
"in the ``elif`` or ``else`` clause is evaluated. The ``elif`` and ``else`` "
"parts are optional. The words ``if``, ``then``, ``elif``, ``else``, and "
"``fi`` are reserved; you cannot use them as identifier names. You can put "
"newlines and white space wherever they make sense. The ``condition`` is a "
"``top_expression`` not an ``expression_list``; semicolons are not allowed. "
"The ``expression_lists`` are semicolon-separated sequences of "
"``top_expressions``. An ``if`` expression returns the result of the last "
"``top_expression`` in the evaluated ``expression_list``, or the empty string"
" if no expression list was evaluated."
msgstr "Les expressions ``If`` évaluent d'abord la ``condition``. Si la ``condition`` est True (une valeur non vide), alors ``expression_list`` de la clause ``then`` est évaluée. Si elle est False, ``expression_list`` de la clause ``elif`` ou ``else`` est évaluée si elle est présente. Les parties ``if`` et ``else`` sont facultatives. Les mots ``if ``, ``then``, ``elif ``, ``else`` et ``fi`` sont réservés ; vous ne pouvez pas les utiliser comme noms d'identifiants. Vous pouvez mettre des retours à la ligne et des espaces partout où cela a un sens. La ``condition`` est une ``top_expression`` et non une ``expression_list`` ; les points-virgules ne sont pas autorisés. Les ``expression_list`` sont des séquences de ``top_expressions`` séparées par des points-virgules. Une expression ``if`` renvoie le résultat de la dernière ``top_expressions`` de la ``top_expression`` évaluée, ou la chaîne vide si aucune liste d'expression n'a été évaluée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:297
msgid "Examples::"
msgstr "Exemples::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:310
msgid "Nested ``if`` example::"
msgstr "Exemple de ``if`` imbriqué::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:323
msgid ""
"As said above, an ``if`` produces a value. This means that all the following"
" are equivalent::"
msgstr "Comme dit plus haut, un ``if`` produit une valeur. Cela signifie que tous les cas suivants sont équivalents ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:329
msgid ""
"As a last example, this program returns the value of the ``series`` column "
"if the book has a series, otherwise the value of the ``title`` column::"
msgstr "Comme dernier exemple, ce programme retourne la valeur de la colonne ``series`` si le livre a une série, sinon la valeur de la colonne ``title`` ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:333
msgid "**For expressions**"
msgstr "**Expressions for**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:335
msgid ""
"The ``for`` expression iterates over a list of values, processing them one "
"at a time. The ``list_expression`` must evaluate either to a metadata field "
"``lookup name`` e.g., ``tags`` or ``#genre``, or to a list of values. The "
":ref:`range() function <range_function>` (see below) generates a list of "
"numbers. If the result is a valid ``lookup name`` then the field's value is "
"fetched and the separator specified for that field type is used. If the "
"result isn't a valid lookup name then it is assumed to be a list of values. "
"The list is assumed to be separated by commas unless the optional keyword "
"``separator`` is supplied, in which case the list values must be separated "
"by the result of evaluating the ``separator_expr``. A separator cannot be "
"used if the list is generated by ``range()``. Each value in the list is "
"assigned to the specified variable then the ``expression_list`` is "
"evaluated. You can use ``break`` to jump out of the loop, and ``continue`` "
"to jump to the beginning of the loop for the next iteration."
msgstr "L'expression ``for`` itère sur une liste de valeurs, en les traitant une par une. L'expression \"list_expression\" doit être évaluée soit par un nom de champ de métadonnées, par exemple ``tags`` ou ``#genre``, soit par une liste de valeurs. Si le résultat est un ``lookup name`` valide, alors la valeur du champ est récupérée et le séparateur spécifié pour ce type de champ est utilisé. Si le résultat n'est pas un nom de référence valide, il est supposé être une liste de valeurs. La liste est supposée être séparée par des virgules, sauf si le mot-clé optionnel ``separator`` est fourni, auquel cas les valeurs de la liste doivent être séparées par le résultat de l'évaluation de l'expression ``separator_expr``. Un séparateur ne peut pas être utilisé si la liste est générée par ``range()``. Chaque valeur de la liste est assignée à la variable spécifiée puis la ``expression_list`` est évaluée. Vous pouvez utiliser ``break`` pour sortir de la boucle, et ``continue`` pour revenir au début de la boucle pour la prochaine itération."

#: ../../__w/calibre/calibre/manual/template_lang.rst:337
msgid ""
"Example: This template removes the first hierarchical name for each value in"
" Genre (``#genre``), constructing a list with the new names::"
msgstr "Exemple : Ce modèle supprime le premier nom hiérarchique pour chaque valeur dans le genre (``#genre``), en construisant une liste avec les nouveaux noms ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:347
msgid ""
"If the original Genre is `History.Military, Science Fiction.Alternate "
"History, ReadMe` then the template returns `Military, Alternate History, "
"ReadMe`. You could use this template in calibre's :guilabel:`Edit metadata "
"in bulk -> Search & replace` with :guilabel:`Search for` set to ``template``"
" to strip off the first level of the hierarchy and assign the resulting "
"value to Genre."
msgstr "Si le Genre original est `Histoire.Militaire, Science Fiction.Histoire alternative, Lisez-moi`, alors le modèle renvoie `Militaire, Histoire alternative, Lisez-moi`. Vous pouvez utiliser ce modèle dans le calibre :guilabel:`Modifier les métadonnées par lot -> Rechercher & remplacer` avec :guilabel:`Rechercher après` défini à ``modèe`` pour supprimer le premier niveau de la hiérarchie et attribuer la valeur résultante à Genre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:350
msgid ""
"Note: the last line in the template, ``new_tags``, isn't strictly necessary "
"in this case because ``for`` returns the value of the last top_expression in"
" the expression list. The value of an assignment is the value of its "
"expression, so the value of the ``for`` statement is what was assigned to "
"``new_tags``."
msgstr "Note : la dernière ligne du modèle, ``new_tags``, n'est pas strictement nécessaire dans ce cas car ``for`` renvoie la valeur de la dernière top_expression de la liste d'expressions. La valeur d'une affectation est la valeur de son expression, donc la valeur de l'instruction ``for`` est ce qui a été affecté à ``new_tags``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:352
msgid "**Function definition**"
msgstr "**Définition de la fonction**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:354
msgid ""
"If you have code in a template that repeats then you can put that code into "
"a local function. The ``def`` keyword starts the definition. It is followed "
"by the function name, the argument list, then the code in the function. The "
"function definition ends with the ``fed`` keyword."
msgstr "Si vous avez du code dans un modèle qui se répète, vous pouvez mettre ce code dans une fonction locale. Le mot clé \"def\" commence la définition. Il est suivi par le nom de la fonction, la liste des arguments, puis le code de la fonction. La définition de la fonction se termine par le mot-clé ``fed''."

#: ../../__w/calibre/calibre/manual/template_lang.rst:356
msgid ""
"Arguments are positional. When a function is called the supplied arguments "
"are matched left to right against the defined parameters, with the value of "
"the argument assigned to the parameter. It is an error to provide more "
"arguments than defined parameters. Parameters can have default values, such "
"as ``a = 25``. If an argument is not supplied for that parameter then the "
"default value is used, otherwise the parameter is set to the empty string."
msgstr "Les arguments sont positionnels. Lorsqu'une fonction est appelée, les arguments fournis sont comparés de gauche à droite aux paramètres définis, la valeur de l'argument étant attribuée au paramètre. C'est une erreur de fournir plus d'arguments que de paramètres définis. Les paramètres peuvent avoir des valeurs par défaut, comme \"a = 25\". Si un argument n'est pas fourni pour ce paramètre, alors la valeur par défaut est utilisée, sinon le paramètre est défini par la chaîne vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:358
msgid "The ``return`` statement can be used in a local function."
msgstr "L'instruction ``return`` peut être utilisée dans une fonction locale."

#: ../../__w/calibre/calibre/manual/template_lang.rst:360
msgid "A function must be defined before it can be used."
msgstr "Une fonction doit être définie avant de pouvoir être utilisée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:362
msgid ""
"Example: This template computes an approximate duration in years, months, "
"and days from a number of days. The function ``to_plural()`` formats the "
"computed values. Note that the example also uses the ``&`` operator::"
msgstr "Exemple : Ce modèle calcule une durée approximative en années, mois et jours à partir d'un nombre de jours. La fonction ``to_plural()`` met en forme les valeurs calculées. Notez que l'exemple utilise également l'opérateur ``&``::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:377
msgid "**Relational operators**"
msgstr "**Opérateurs relationnels**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:379
msgid ""
"Relational operators return ``'1'`` if the comparison is true, otherwise the"
" empty string ('')."
msgstr "Les opérateurs relationnels renvoient ``'1'`` si la comparaison est vraie, sinon la chaîne vide ('')."

#: ../../__w/calibre/calibre/manual/template_lang.rst:381
msgid ""
"There are two forms of relational operators: string comparisons and numeric "
"comparisons."
msgstr "Il existe deux formes d'opérateurs relationnels : les comparaisons de chaînes de caractères et les comparaisons numériques."

#: ../../__w/calibre/calibre/manual/template_lang.rst:383
msgid ""
"String comparisons do case-insensitive string comparison using lexical "
"order. The supported string comparison operators are ``==``, ``!=``, ``<``, "
"``<=``, ``>``, ``>=``, ``in``, and ``inlist``. For the ``in`` operator, the "
"result of the left hand expression is interpreted as a regular expression "
"pattern. The ``in`` operator is True if the value of left-hand regular "
"expression matches the value of the right hand expression. The ``inlist`` "
"operator is true if the left hand regular expression matches any one of the "
"items in the right hand list where the items in the list are separated by "
"commas. The matches are case-insensitive."
msgstr "Les comparaisons de chaînes de caractères effectuent une comparaison insensible à la casse en utilisant l'ordre lexical. Les opérateurs de comparaison de chaînes de caractères pris en charge sont ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``, ``in``, et ``inlist``. Pour l'opérateur ``in``, le résultat de l'expression de gauche est interprété comme un motif d'expression régulière. L'opérateur ``in`` est True si la valeur de l'expression régulière de gauche correspond à la valeur de l'expression de droite. L'opérateur ``inlist`` est vrai si l'expression régulière de gauche correspond à l'un des éléments de la liste de droite, les éléments de la liste étant séparés par des virgules. Les correspondances sont insensibles à la casse."

#: ../../__w/calibre/calibre/manual/template_lang.rst:386
msgid ""
"The numeric comparison operators are ``==#``, ``!=#``, ``<#``, ``<=#``, "
"``>#``, ``>=#``. The left and right expressions must evaluate to numeric "
"values with two exceptions: both the string value \"None\" (undefined field)"
" and the empty string evaluate to the value zero."
msgstr "Les opérateurs de comparaison numérique sont ``==#``, ``!=#``, ``<#``, ``<=#``, ``>#``, ``>=#``. Les expressions de gauche et de droite doivent être évaluées par des valeurs numériques, à deux exceptions près : la chaîne de caractères \"None\" (champ indéfini) et la chaîne de caractères vide sont évaluées par la valeur zéro."

#: ../../__w/calibre/calibre/manual/template_lang.rst:390
msgid ""
"``program: field('series') == 'foo'`` returns ``'1'`` if the book's series "
"is 'foo', otherwise ``''``."
msgstr "``program:field('series') == 'foo'`` renvoie ``'1'`` si la série du livre est 'foo', sinon ``''``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:391
msgid ""
"``program: 'f.o' in field('series')`` returns ``'1'`` if the book's series "
"matches the regular expression ``f.o`` (e.g., `foo`, `Off Onyx`, etc.), "
"otherwise ``''``."
msgstr "``Program: 'f.o' in field('series')`` renvoie `'1'`` si la série du livre correspond à l'expression régulière ``f.o`` (par exemple, `foo`, `Off Onyx`, etc.), sinon ``''``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:392
msgid ""
"``program: 'science' inlist field('#genre')`` returns ``'1'`` if any of the "
"book's genres match the regular expression ``science``, e.g., `Science`, "
"`History of Science`, `Science Fiction` etc.), otherwise ``''``."
msgstr "``Program: 'science' inlist field('#genre')`` renvoie ``'1'`` si l'un des genres du livre correspond à l'expression régulière ``science``, par exemple, `Science`, `Histoire de la science`, `Science Fiction` etc., sinon ``''``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:393
msgid ""
"``program: '^science$' inlist field('#genre')`` returns ``'1'`` if any of "
"the book's genres exactly match the regular expression ``^science$``, e.g., "
"`Science`. The genres `History of Science` and `Science Fiction` don't "
"match. If there isn't a match then returns ``''``."
msgstr "``Program: '^science$' inlist field('#genre')`` renvoie `'1'`` si l'un des genres du livre correspond exactement à l'expression régulière ``^science$``, par exemple, `Science`. Les genres `Histoire des sciences` et `Science Fiction` ne correspondent pas. S'il n'y a pas de correspondance, elle renvoie ``''``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:394
msgid ""
"``program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` returns"
" ``'bar'`` if the book's series is not ``foo``. Otherwise it returns "
"``'mumble'``."
msgstr "``Program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` renvoie ``'bar'`` si la série du livre n'est pas ``foo``. Sinon, renvoie ``mumble``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:395
msgid ""
"``program: if field('series') == 'foo' || field('series') == '1632' then "
"'yes' else 'no' fi`` returns ``'yes'`` if series is either ``'foo'`` or "
"``'1632'``, otherwise ``'no'``."
msgstr "``Program: if field('series') == 'foo' || field('series') == '1632' then 'yes' else 'no' fi`` renvoie ``'yes'`` si séries existe soit ``'foo'`` soit ``'1632'``, sinon `'no'``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:396
msgid ""
"``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi`` "
"returns ``'yes'`` if series is either ``'foo'`` or ``'1632'``, otherwise "
"``'no'``."
msgstr "``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi``  renvoie ``'yes'`` si la série existe soit ``'foo'`` ou ``'1632'``, sinon ``'no'``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:397
msgid ""
"``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the "
"``>`` operator does a lexical comparison."
msgstr "``program: if '11' > '2' then 'yes' else 'no' fi`` `renvoie ``'no'`` parce que l'opérateur ``>`` fait une comparaison lexicale."

#: ../../__w/calibre/calibre/manual/template_lang.rst:398
msgid ""
"``program: if 11 ># 2 then 'yes' else 'no' fi`` returns ``'yes'`` because "
"the ``>#`` operator does a numeric comparison."
msgstr "``Program: if 11 ># 2 then 'yes' else 'no' fi`` renvoie ``'yes'`` parce que l'opérateur ``>#`` effectue une comparaison numérique."

#: ../../__w/calibre/calibre/manual/template_lang.rst:400
msgid "**Additional available functions**"
msgstr "**Fonctions supplémentaires disponibles**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:402
msgid ""
"The following functions are available in addition to those described in "
":ref:`Single Function Mode <single_mode>`."
msgstr "Les fonctions suivantes sont disponibles en plus de celles décrites dans :ref:`Mode fonction unique`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:404
msgid ""
"In `GPM` the functions described in `Single Function Mode` all require an "
"additional first parameter specifying the value to operate upon. All "
"parameters are expression_lists (see the grammar above)."
msgstr "Dans `MPG`, les fonctions décrites dans `Mode Fonction Simple` requièrent toutes un premier paramètre supplémentaire spécifiant la valeur sur laquelle opérer. Tous les paramètres sont des listes d'expressions (voir la grammaire ci-dessus)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:406
msgid ""
"``add(x [, y]*)`` -- returns the sum of its arguments. Throws an exception "
"if an argument is not a number. In most cases you can use the ``+`` operator"
" instead of this function."
msgstr "``add(x [, y]*)`` -- renvoie la somme de ses arguments. Lance une exception si un argument n'est pas un nombre. Dans la plupart des cas, vous pouvez utiliser l'opérateur ``+`` à la place de cette fonction."

#: ../../__w/calibre/calibre/manual/template_lang.rst:407
msgid ""
"``and(value [, value]*)`` -- returns the string \"1\" if all values are not "
"empty, otherwise returns the empty string. You can have as many values as "
"you want. In most cases you can use the ``&&`` operator instead of this "
"function.  One reason not to replace ``and`` with ``&&`` is if short-"
"circuiting can change the results because of side effects. For example, "
"``and(a='',b=5)`` will always do both assignments, where the ``&&`` operator"
" won't do the second."
msgstr "``and(value [, value]*)`` -- retourne la chaîne \"1\" si toutes les valeurs ne sont pas vides, sinon retourne la chaîne vide. Vous pouvez avoir autant de valeurs que vous le souhaitez. Dans la plupart des cas, vous pouvez utiliser l'opérateur ``&&`` à la place de cette fonction. Une raison de ne pas remplacer ``and`` par ``&&`` est que le court-circuitage peut modifier les résultats à cause d'effets secondaires. Par exemple, ``et(a='',b=5)`` fera toujours les deux affectations, alors que l'opérateur ``&&`` ne fera pas la seconde."

#: ../../__w/calibre/calibre/manual/template_lang.rst:408
msgid ""
"``assign(id, val)`` -- assigns ``val`` to ``id``, then returns ``val``. "
"``id`` must be an identifier, not an expression. In most cases you can use "
"the ``=`` operator instead of this function."
msgstr "``assign(id, val)`` -- affecte ``val`` à ``id``, puis retourne ``val``. ``id`` doit être un identifiant, pas une expression. Dans la plupart des cas, vous pouvez utiliser l'opérateur ``=`` à la place de cette fonction."

#: ../../__w/calibre/calibre/manual/template_lang.rst:409
msgid ""
"``approximate_formats()`` -- return a comma-separated list of formats "
"associated with the book. There is no guarantee that the list is correct, "
"although it probably is. This and other zero-parameter functions can be "
"called in Template Program Mode (see below) using the template "
"``{:'approximate_formats()'}``. Note that resulting format names are always "
"uppercase, as in EPUB. The ``approximate_formats()`` function is "
"significantly faster than the ``formats_...`` functions discussed below."
msgstr "``approximate_formats()`` -- renvoie une liste, séparée par des virgules, des formats associés au livre. Il n'y a aucune garantie que la liste soit correcte, bien qu'elle le soit probablement. Cette fonction et d'autres fonctions à zéro paramètre peuvent être appelées en mode programme modèle (voir ci-dessous) en utilisant le modèle ``{:'approximate_formats()'}``. Notez que les noms de formats résultants sont toujours en majuscules, comme dans EPUB. La fonction ``approximate_formats()`` est nettement plus rapide que les fonctions ``formats_...`` présentées ci-dessous."

#: ../../__w/calibre/calibre/manual/template_lang.rst:410
msgid ""
"``author_links(val_separator, pair_separator)`` -- returns a string "
"containing a list of authors and those authors' link values in the form::"
msgstr "``author_links(val_separator, pair_separator)`` -- renvoie une chaîne contenant une liste d'auteurs et les valeurs des liens de ces auteurs sous la forme ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:414
msgid ""
"An author is separated from its link value by the ``val_separator`` string "
"with no added spaces. ``author:linkvalue`` pairs are separated by the "
"``pair_separator`` string argument with no added spaces. It is up to you to "
"choose separator strings that do not occur in author names or links. An "
"author is included even if the author link is empty."
msgstr "Un auteur est séparé de sa valeur de lien par la chaîne ``val_separator`` sans espaces ajoutés. Les paires ``author:linkvalue`` sont séparées par la chaîne de caractères ``pair_separator``, sans espaces ajoutés. C'est à vous de choisir des chaînes de séparation qui n'apparaissent pas dans les noms d'auteurs ou les liens. Un auteur est inclus même si le lien de l'auteur est vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:415
msgid ""
"``author_sorts(val_separator)`` -- returns a string containing a list of "
"author's sort values for the authors of the book. The sort is the one in the"
" author metadata information (different from the author_sort in books). The "
"returned list has the form ``author sort 1`` ``val_separator`` ``author sort"
" 2`` etc. with no added spaces. The author sort values in this list are in "
"the same order as the authors of the book. If you want spaces around "
"``val_separator`` then include them in the ``val_separator`` string."
msgstr "``author_sorts(val_separator)`` --  renvoie une chaîne contenant une liste des valeurs de tri de l'auteur pour les auteurs du livre. Le tri est celui des métadonnées auteur (différente de l'author_sort dans les livres). La liste renvoyée a la forme ``author sort 1`` ``val_separator`` ``author sort 2`` etc. Les valeurs de tri auteur dans cette liste sont dans le même ordre que les auteurs du livre. Si vous voulez les espaces autour du ``val_separator`` incluez les alors dans la chaîne ``val_separator``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:416
msgid ""
"``book_count(query, use_vl)`` -- returns the count of books found by "
"searching for ``query``. If ``use_vl`` is ``0`` (zero) then virtual "
"libraries are ignored. This function and its companion ``book_values()`` are"
" particularly useful in template searches, supporting searches that combine "
"information from many books such as looking for series with only one book. "
"It cannot be used in composite columns unless the tweak "
"``allow_template_database_functions_in_composites`` is set to True. It can "
"be used only in the GUI."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:418
msgid ""
"For example this template search uses this function and its companion to "
"find all series with only one book:"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:420
msgid ""
"Define a stored template (using :guilabel:`Preferences->Advanced->Template "
"functions`) named ``series_only_one_book`` (the name is arbitrary). The "
"template is::"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:435
msgid ""
"The first time the template runs (the first book checked) it stores the "
"results of the database lookups in a ``global`` template variable named "
"``vals``. These results are used to check subsequent books without redoing "
"the lookups."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:437
msgid "Use the stored template in a template search::"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:441
msgid ""
"Using a stored template instead of putting the template into the search "
"eliminates problems caused by the requirement to escape quotes in search "
"expressions."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:442
msgid ""
"``book_values(column, query, sep, use_vl)`` -- returns a list of the unique "
"values contained in the column ``column`` (a lookup name), separated by "
"``sep``, in the books found by searching for ``query``. If ``use_vl`` is "
"``0`` (zero) then virtual libraries are ignored. This function and its "
"companion ``book_count()`` are particularly useful in template searches, "
"supporting searches that combine information from many books such as looking"
" for series with only one book. It cannot be used in composite columns "
"unless the tweak ``allow_template_database_functions_in_composites`` is set "
"to True. It can be used only in the GUI."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:443
msgid ""
"``booksize()`` -- returns the value of the calibre 'size' field. Returns '' "
"if there are no formats."
msgstr "``booksize()`` -- renvoie la valeur du champ 'size' de calibre. Renvoie '' s'il n'y a pas de formats."

#: ../../__w/calibre/calibre/manual/template_lang.rst:444
msgid ""
"``check_yes_no(field_name, is_undefined, is_false, is_true)`` -- checks if "
"the value of the yes/no field named by the lookup name ``field_name`` is one"
" of the values specified by the parameters, returning ``'yes'`` if a match "
"is found otherwise returning the empty string. Set the parameter "
"``is_undefined``, ``is_false``, or ``is_true`` to 1 (the number) to check "
"that condition, otherwise set it to 0. Example:"
msgstr "``check_yes_no(field_name, is_undefined, is_false, is_true)`` -- vérifie si la valeur du champ oui/non nommé par le nom de la référence externe ``field_name`` est l'une des valeurs spécifiées par les paramètres, renvoyant ``'yes'`` si une correspondance est trouvée sinon renvoyant la chaîne vide. Définissez le paramètre ``is_undefined``, ``is_false`` ou ``is_true`` à 1 (le nombre) pour vérifier cette condition, sinon définissez-le à 0. Exemple :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:446
msgid ""
"``check_yes_no(\"#bool\", 1, 0, 1)`` returns ``'yes'`` if the yes/no field "
"``#bool`` is either True or undefined (neither True nor False)."
msgstr "``check_yes_no(\"#bool\", 1, 0, 1)`` renvoie ``'yes'`` si le champ oui/non ``#bool`` est soit Vrai, soit indéfini (ni Vrai, ni Faux)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:448
msgid ""
"More than one of ``is_undefined``, ``is_false``, or ``is_true`` can be set "
"to 1."
msgstr "Plus d'un élément parmi \" is_undefined \", \" is_false \" ou \" is_true \" peut être mis à 1."

#: ../../__w/calibre/calibre/manual/template_lang.rst:449
msgid ""
"``ceiling(x)`` -- returns the smallest integer greater than or equal to "
"``x``. Throws an exception if ``x`` is not a number."
msgstr "``ceiling(x)`` -- renvoie le plus petit entier supérieur ou égal à ``x``. Envoie une exception si ``x`` n'est pas un nombre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:450
msgid ""
"``character(character_name)`` -- returns the character named by "
"character_name. For example, ``character('newline')`` returns a newline "
"character (``'\\n'``). The supported character names are ``newline``, "
"``return``, ``tab``, and ``backslash``."
msgstr "``character(character_name)`` -- renvoie le caractère désigné par character_name. Par exemple, ``character('newline')`` renvoie un caractère de nouvelle ligne (``'\\n'``). Les noms de caractères pris en charge sont ``newline``, ``return``, ``tab``, et ``backslash``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:451
msgid ""
"``cmp(x, y, lt, eq, gt)`` -- compares ``x`` and ``y`` after converting both "
"to numbers. Returns ``lt`` if ``x <# y``, ``eq`` if ``x ==# y``, otherwise "
"``gt``. This function can usually be replaced with one of the numeric "
"compare operators (``==#``, ``<#``, ``>#``, etc)."
msgstr "``cmp(x, y, lt, eq, gt)`` -- compare ``x`` et ``y`` après les avoir convertis en nombres. Renvoie ``lt`` si ``x <# y``, ``eq`` si ``x ==# y``, sinon ``gt``. Cette fonction peut généralement être remplacée par l'un des opérateurs de comparaison numérique (``==#``, ``<#``, ``>#``, etc)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:452
msgid ""
"``connected_device_name(storage_location_key)`` -- if a device is connected "
"then return the device name, otherwise return the empty string. Each storage"
" location on a device has its own device name. The ``storage_location_key`` "
"names are ``'main'``, ``'carda'`` and ``'cardb'``. This function works only "
"in the GUI."
msgstr "``connected_device_name(storage_location_key)`` -- si un périphérique est connecté alors retourne le nom du périphérique, sinon retourne la chaîne vide. Chaque emplacement de stockage sur un périphérique peut avoir un nom différent. Les noms ``storage_location_key``  sont ``'main'``, ``'carda'`` et ``'cardb'``. Cette fonction ne fonctionne que dans l'interface graphique."

#: ../../__w/calibre/calibre/manual/template_lang.rst:453
msgid ""
"``connected_device_uuid(storage_location_key)`` -- if a device is connected "
"then return the device uuid (unique id), otherwise return the empty string. "
"Each storage location on a device has a different uuid. The "
"``storage_location_key`` location names are ``'main'``, ``'carda'`` and "
"``'cardb'``. This function works only in the GUI."
msgstr "``connected_device_uuid(storage_location_key)`` -- si un périphérique est connecté alors retourne l'uuid du périphérique (id unique), sinon retourne la chaîne vide. Chaque emplacement de stockage sur un périphérique a un uuid différent. Les noms ``storage_location_key``  sont ``'main'``, ``'carda'`` et ``'cardb'``. Cette fonction ne fonctionne que dans l'interface graphique."

#: ../../__w/calibre/calibre/manual/template_lang.rst:454
msgid ""
"``current_library_name()`` -- return the last name on the path to the "
"current calibre library."
msgstr "``current_library_name()`` -- renvoie le dernier nom sur le chemin de la bibliothèque calibre actuelle."

#: ../../__w/calibre/calibre/manual/template_lang.rst:455
msgid ""
"``current_library_path()`` -- return the full path to the current calibre "
"library."
msgstr "``current_library_path()`` -- renvoie le chemin complet vers la bibliothèque calibre actuelle."

#: ../../__w/calibre/calibre/manual/template_lang.rst:456
msgid ""
"``current_virtual_library_name()`` -- return the name of the current virtual"
" library if there is one, otherwise the empty string. Library name case is "
"preserved. Example: ``program: current_virtual_library_name()``. This "
"function works only in the GUI."
msgstr "current_virtual_library_name() -- retourne le nom de la bibliothèque virtuelle actuelle s'il y en a une, sinon la chaîne vide. La casse du nom de la bibliothèque est préservée. Exemple : \"program:current_virtual_library_name()\". Cette fonction ne fonctionne que dans l'Interface Graphique."

#: ../../__w/calibre/calibre/manual/template_lang.rst:457
msgid ""
"``date_arithmetic(date, calc_spec, fmt)`` -- Calculate a new date from "
"``date`` using ``calc_spec``. Return the new date formatted according to "
"optional ``fmt``: if not supplied then the result will be in ISO format. The"
" calc_spec is a string formed by concatenating pairs of ``vW`` "
"(``valueWhat``) where ``v`` is a possibly-negative number and W is one of "
"the following letters:"
msgstr "``date_arithmetic(date, calc_spec, fmt)`` -- Calcule une nouvelle date à partir de ``date`` en utilisant ``calc_spec``. Retourne la nouvelle date formatée selon l'option ``fmt`` : si elle n'est pas fournie, le résultat sera au format ISO. calc_spec est une chaîne de caractères formée par la concaténation de paires de ``vW`` (valueWhat) où ``v`` est un nombre éventuellement négatif et W est l'une des lettres suivantes :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:459
msgid "``s``: add ``v`` seconds to ``date``"
msgstr "``s``: ajoute ``v`` secondes à ``date``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:460
msgid "``m``: add ``v`` minutes to ``date``"
msgstr "``m``: ajoute ``v`` minutes à ``date``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:461
msgid "``h``: add ``v`` hours to ``date``"
msgstr "``h``: ajoute ``v`` heures à ``date``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:462
msgid "``d``: add ``v`` days to ``date``"
msgstr "``d``: ajoute ``v`` jours à ``date``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:463
msgid "``w``: add ``v`` weeks to ``date``"
msgstr "``w``: ajoute ``v`` semaines à ``date``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:464
msgid "``y``: add ``v`` years to ``date``, where a year is 365 days."
msgstr "``y``: ajoute ``v`` années à ``date``, où une année compte 365 jours."

#: ../../__w/calibre/calibre/manual/template_lang.rst:466
msgid ""
"Example: ``'1s3d-1m'`` will add 1 second, add 3 days, and subtract 1 minute "
"from ``date``."
msgstr "Exemple : ``'1s3d-1m'`` ajoutera 1 seconde, ajoutera 3 jours, et soustraira 1 minute de ``date``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:467
msgid ""
"``days_between(date1, date2)`` -- return the number of days between "
"``date1`` and ``date2``. The number is positive if ``date1`` is greater than"
" ``date2``, otherwise negative. If either ``date1`` or ``date2`` are not "
"dates, the function returns the empty string."
msgstr "``days_between(date1, date2)`` -- renvoie le nombre de jours entre ``date1`` et ``date2``. Le nombre est positif si ``date1`` est plus grand que ``date2``, sinon négatif. Si ``date1`` ou ``date2`` ne sont pas des dates, la fonction renvoie une chaîne vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:468
msgid ""
"``divide(x, y)`` -- returns ``x / y``. Throws an exception if either ``x`` "
"or ``y`` are not numbers. This function can usually be replaced by the ``/``"
" operator."
msgstr "``divide(x, y)`` -- renvoie ``x / y``. Lance une exception si ``x`` ou ``y`` ne sont pas des nombres. Cette fonction peut généralement être remplacée par l'opérateur ``/``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:469
msgid ""
"``eval(string)`` -- evaluates the string as a program, passing the local "
"variables. This permits using the template processor to construct complex "
"results from local variables. In :ref:`Template Program Mode "
"<template_mode>`, because the `{` and `}` characters are interpreted before "
"the template is evaluated you must use `[[` for the `{` character and `]]` "
"for the ``}`` character. They are converted automatically. Note also that "
"prefixes and suffixes (the `|prefix|suffix` syntax) cannot be used in the "
"argument to this function when using :ref:`Template Program Mode "
"<template_mode>`."
msgstr "``eval(string)`` -- évalue la chaîne comme un programme, en passant les variables locales. Cela permet d'utiliser le processeur de modèles pour construire des résultats complexes à partir de variables locales. En :ref:`Mode Modèle de Programme<template_mode>`, comme les caractères `{` et `}` sont interprétés avant l'évaluation du modèle, vous devez utiliser `[[`] pour le caractère `{` et `]]` pour le caractère ``}``. Ils sont convertis automatiquement. Notez également que les préfixes et les suffixes (la syntaxe `|prefix|suffix`) ne peuvent pas être utilisés dans l'argument de cette fonction lors de l'utilisation de :ref:`Mode Modèle de Programme<template_mode>`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:470
msgid ""
"``field(lookup_name)`` -- returns the value of the metadata field with "
"lookup name ``lookup_name``."
msgstr "``field(lookup_name)`` -- renvoie la valeur du champ de métadonnées avec le nom de recherche ``lookup_name``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:471
msgid ""
"``field_exists(field_name)`` -- checks if a field (column) with the lookup "
"name ``field_name`` exists, returning ``'1'`` if so and the empty string if "
"not."
msgstr "``field_exists(field_name)`` -- vérifie si un champ (colonne) avec le nom de recherche ``field_name`` existe, retournant `'1'`` si c'est le cas et la chaîne vide si non."

#: ../../__w/calibre/calibre/manual/template_lang.rst:472
msgid ""
"``finish_formatting(val, fmt, prefix, suffix)`` -- apply the format, prefix,"
" and suffix to a value in the same way as done in a template like "
"``{series_index:05.2f| - |- }``. This function is provided to ease "
"conversion of complex single-function- or template-program-mode templates to"
" `GPM` Templates. For example, the following program produces the same "
"output as the above template::"
msgstr "``finish_formatting(val, fmt, prefix, suffix)`` -- applique le format, le préfixe et le suffixe à une valeur de la même manière que dans un modèle comme ``{series_index:05.2f| - |- }``. Cette fonction est fournie pour faciliter la conversion des modèles complexes single-function- ou modèles template-program-mode en modèles `MGP`. Par exemple, le programme suivant produit la même sortie que le modèle ci-dessus ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:476
msgid ""
"Another example: for the template "
"``{series:re(([^\\s])[^\\s]+(\\s|$),\\1)}{series_index:0>2s| - | - "
"}{title}`` use::"
msgstr "Un autre exemple: pour le modèle ``{series:re(([^\\s])[^\\s]+(\\s|$),\\1)}{series_index:0>2s| - | - }{title}`` utilisez::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:485
msgid ""
"``first_matching_cmp(val, [ cmp, result, ]* else_result)`` -- compares ``val"
" < cmp`` in sequence, returning the associated result for the first "
"comparison that succeeds. Returns else_result if no comparison succeeds. "
"Example::"
msgstr "``first_matching_cmp(val, [ cmp, result, ]* else_result)`` -- compare ``val < cmp`` en séquence, en retournant le résultat associé à la première comparaison qui réussit. Retourne else_result si aucune comparaison ne réussit. Exemple ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:490
msgid ""
"returns ``\"large\"``. The same example with a first value of 16 returns "
"``\"giant\"``."
msgstr "renvoie ``\"grand\"``. Le même exemple avec une première valeur de 16 renvoie ``\"géant\"``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:492
msgid ""
"``first_non_empty(value [, value]*)`` -- returns the first ``value`` that is"
" not empty. If all values are empty, then the empty string is returned. You "
"can have as many values as you want."
msgstr "``first_non_empty(value [, value]*)`` -- retourne la première valeur non vide. Si toutes les valeurs sont vides, alors la chaîne vide est retournée. Vous pouvez avoir autant de valeurs que vous voulez."

#: ../../__w/calibre/calibre/manual/template_lang.rst:493
msgid ""
"``floor(x)`` -- returns the largest integer less than or equal to ``x``. "
"Throws an exception if ``x`` is not a number."
msgstr "``floor(x)`` -- renvoie le plus grand entier inférieur ou égal à ``x``. Envoie une exception si ``x`` n'est pas un nombre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:494
msgid ""
"``format_date(val, format_string)`` -- format the value, which must be a "
"date string, using the format_string, returning a string. The formatting "
"codes are:"
msgstr "``format_date(val, format_string)`` -- formate la valeur, qui doit être une chaîne date, en utilisant format_string, retournant une chaîne. Les codes de formatage sont::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:496
msgid "``d    :`` the day as number without a leading zero (1 to 31)"
msgstr "``d :`` le jour sous la forme d'un nombre sans zéro initial (1 à 31)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:497
msgid "``dd   :`` the day as number with a leading zero (01 to 31)"
msgstr "``dd :`` le jour sous la forme d'un nombre avec un zéro initial (1 à 31)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:498
msgid "``ddd  :`` the abbreviated localized day name (e.g. \"Mon\" to \"Sun\")."
msgstr "``ddd :`` le nom abrégé du jour localisé (par exemple de \"Lun\" à \"Dim\")."

#: ../../__w/calibre/calibre/manual/template_lang.rst:499
msgid "``dddd :`` the long localized day name (e.g. \"Monday\" to \"Sunday\")."
msgstr "``dddd :`` le nom long du jour localisé (par exemple de \"lundi\" à \"dimanche\")."

#: ../../__w/calibre/calibre/manual/template_lang.rst:500
msgid "``M    :`` the month as number without a leading zero (1 to 12)."
msgstr "``M :`` le mois sous la forme d'un nombre sans zéro initial (1 à 12)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:501
msgid "``MM   :`` the month as number with a leading zero (01 to 12)"
msgstr "``MM :`` le mois sous la forme d'un nombre avec un zéro initial (1 à 12)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:502
msgid "``MMM  :`` the abbreviated localized month name (e.g. \"Jan\" to \"Dec\")."
msgstr "``MMM :`` le nom abrégé du mois localisé (par exemple de \"Jan\" à \"Déc\")."

#: ../../__w/calibre/calibre/manual/template_lang.rst:503
msgid "``MMMM :`` the long localized month name (e.g. \"January\" to \"December\")."
msgstr "``MMMM :`` le nom long du mois localisé (par exemple de \"janvier\" à \"décembre\")."

#: ../../__w/calibre/calibre/manual/template_lang.rst:504
msgid "``yy   :`` the year as two digit number (00 to 99)."
msgstr "``yy :`` l'année sous la forme d'un nombre à deux chiffres (00 à 99)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:505
msgid "``yyyy :`` the year as four digit number."
msgstr "``yyyy :`` l'année sous la forme d'un nombre à quatre chiffres."

#: ../../__w/calibre/calibre/manual/template_lang.rst:506
msgid ""
"``h    :`` the hours without a leading 0 (0 to 11 or 0 to 23, depending on "
"am/pm)"
msgstr "``h :`` les heures sans le premier 0 (0 à 11 ou 0 à 23, selon am/pm)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:507
msgid ""
"``hh   :`` the hours with a leading 0 (00 to 11 or 00 to 23, depending on "
"am/pm)"
msgstr "``hh :`` les heures avec le premier 0 (00 à 11 ou 00 à 23, selon am/pm)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:508
msgid "``m    :`` the minutes without a leading 0 (0 to 59)"
msgstr "``m :`` les minutes sans le premier 0 (0 à 59)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:509
msgid "``mm   :`` the minutes with a leading 0 (00 to 59)"
msgstr "``mm :`` les minutes avec le premier 0 (00 à 59)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:510
msgid "``s    :`` the seconds without a leading 0 (0 to 59)"
msgstr "``s :`` les secondes sans le premier 0 (0 à 59)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:511
msgid "``ss   :`` the seconds with a leading 0 (00 to 59)"
msgstr "``ss :`` les secondes avec un 0 en tête (00 à 59)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:512
msgid ""
"``ap   :`` use a 12-hour clock instead of a 24-hour clock, with 'ap' "
"replaced by the localized string for am or pm."
msgstr "``ap :`` utilise une horloge de 12 heures au lieu d'une horloge de 24 heures, avec 'ap' remplacé par la chaîne localisée pour am ou pm."

#: ../../__w/calibre/calibre/manual/template_lang.rst:513
msgid ""
"``AP   :`` use a 12-hour clock instead of a 24-hour clock, with 'AP' "
"replaced by the localized string for AM or PM."
msgstr "``AP :`` utilise une horloge de 12 heures au lieu d'une horloge de 24 heures, avec 'AP' remplacé par la chaîne localisée pour AM ou PM."

#: ../../__w/calibre/calibre/manual/template_lang.rst:514
msgid ""
"``iso  :`` the date with time and timezone. Must be the only format present."
msgstr "``iso :`` la date avec l'heure et le fuseau horaire. Ce doit être le seul format présent."

#: ../../__w/calibre/calibre/manual/template_lang.rst:515
msgid ""
"``to_number   :`` convert the date & time into a floating point number (a "
"`timestamp`)"
msgstr "``to_number :`` convertit la date et l'heure en un nombre à virgule flottante (un `timestamp`)"

#: ../../__w/calibre/calibre/manual/template_lang.rst:516
msgid ""
"``from_number :`` convert a floating point number (a `timestamp`) into an "
"``iso`` formatted date. If you want a different date format then add the "
"desired formatting string after ``from_number`` and a colon (``:``). "
"Example: ``from_number:MMM dd yyyy``"
msgstr "``from_number :`` convertit un nombre à virgule flottante (un `timestamp`) en une date formatée ``iso``. Si vous souhaitez un format de date différent, ajoutez la chaîne de formatage souhaitée après ``from_number`` et un deux-points (``:``). Exemple : ``from_number:MMM dd yyyy``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:518
msgid ""
"You might get unexpected results if the date you are formatting contains "
"localized month names, which can happen if you changed the date format "
"tweaks to contain ``MMMM``. In this case, instead of using the ``field()`` "
"function as in::"
msgstr "Vous pouvez obtenir des résultats inattendus si la date que vous formatez contient des noms de mois localisés, ce qui peut se produire si vous avez modifié les ajustements de format de date pour qu'ils contiennent ``MMMM``. Dans ce cas, au lieu d'utiliser la fonction ``field()`` comme dans ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:522
msgid "use the ``raw_field()`` function as in::"
msgstr "utiliser la fonction ``raw_field()`` comme dans ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:526
msgid ""
"``formats_modtimes(date_format_string)`` -- return a comma-separated list of"
" colon-separated items ``FMT:DATE`` representing modification times for the "
"formats of a book. The ``date_format_string`` parameter specifies how the "
"date is to be formatted. See the ``format_date()`` function for details. You"
" can use the ``select`` function to get the modification time for a specific"
" format. Note that format names are always uppercase, as in EPUB."
msgstr "``formats_modtimes(date_format_string)`` -- renvoie une liste séparée par des virgules d'éléments séparés par des deux points ``FMT:DATE`` représentant les heures de modification des formats d'un livre. Le paramètre ``date_format_string`` spécifie comment la date doit être formatée. Voir la fonction ``format_date()`` pour plus de détails. Vous pouvez utiliser la fonction ``select`` pour obtenir l'heure de modification d'un format spécifique. Notez que les noms de format sont toujours en majuscules, comme dans EPUB."

#: ../../__w/calibre/calibre/manual/template_lang.rst:527
msgid ""
"``formats_paths()`` -- return a comma-separated list of colon-separated "
"items ``FMT:PATH`` giving the full path to the formats of a book. You can "
"use the select function to get the path for a specific format. Note that "
"format names are always uppercase, as in EPUB."
msgstr "``formats_paths()`` -- retourne une liste d'éléments séparés par des virgules et des deux-points ``FMT:PATH`` donnant le chemin complet vers les formats d'un livre. Vous pouvez utiliser la fonction select pour obtenir le chemin d'accès à un format spécifique. Notez que les noms de format sont toujours en majuscules, comme dans EPUB."

#: ../../__w/calibre/calibre/manual/template_lang.rst:528
msgid ""
"``formats_sizes()`` -- return a comma-separated list of colon-separated "
"``FMT:SIZE`` items giving the sizes in bytes of the formats of a book. You "
"can use the select function to get the size for a specific format. Note that"
" format names are always uppercase, as in EPUB."
msgstr "``formats_sizes()`` -- renvoie une liste d'éléments ``FMT:SIZE`` séparés par des virgules, donnant les tailles en octets des formats d'un livre. Vous pouvez utiliser la fonction select pour obtenir la taille d'un format spécifique. Notez que les noms de format sont toujours en majuscules, comme dans EPUB."

#: ../../__w/calibre/calibre/manual/template_lang.rst:529
msgid ""
"``fractional_part(x)`` -- returns the value after the decimal point. For "
"example, ``fractional_part(3.14)`` returns ``0.14``. Throws an exception if "
"``x`` is not a number."
msgstr "``fractional_part(x)`` -- renvoie la valeur après la virgule. Par exemple, ``fractional_part(3.14)`` renvoie ``0.14``. Envoie une exception si ``x`` n'est pas un nombre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:530
msgid ""
"``has_cover()`` -- return ``'Yes'`` if the book has a cover, otherwise the "
"empty string."
msgstr "``has_cover()`` -- retourne ``'Yes'`` si le livre a une couverture, sinon la chaîne vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:531
msgid ""
"``is_marked()`` -- check whether the book is `marked` in calibre. If it is "
"then return the value of the mark, either ``'true'`` (lower case) or a "
"comma-separated list of named marks. Returns ``''`` (the empty string) if "
"the book is not marked. This function works only in the GUI."
msgstr "``is_marked()`` -- vérifie si le livre est `marqué` dans calibre. S'il l'est, retourne la valeur de la marque, soit ``true'`` (minuscule), soit une liste de marques nommées, séparées par des virgules.. Si le livre n'est pas marqué, retourne ``\"`` (chaîne vide). Cette fonction ne fonctionne que dans l'interface graphique."

#: ../../__w/calibre/calibre/manual/template_lang.rst:532
msgid ""
"``language_codes(lang_strings)`` -- return the `language codes "
"<https://www.loc.gov/standards/iso639-2/php/code_list.php>`_ for the "
"language names passed in `lang_strings`. The strings must be in the language"
" of the current locale. ``Lang_strings`` is a comma-separated list."
msgstr "``language_codes(lang_strings)`` -- retourne les `codes de langue`_ pour les noms de langue passés dans `lang_strings`. Les chaînes de caractères doivent être dans la langue de la locale courante. ``Lang_strings`` est une liste séparée par des virgules."

#: ../../__w/calibre/calibre/manual/template_lang.rst:533
msgid ""
"``list_contains(value, separator, [ pattern, found_val, ]* not_found_val)`` "
"-- (Alias of ``in_list``) Interpreting the value as a list of items "
"separated by ``separator``, evaluate the ``pattern`` against each value in "
"the list. If the ``pattern`` matches any value then return ``found_val``, "
"otherwise return ``not_found_val``. The ``pattern`` and ``found_value`` can "
"be repeated as many times as desired, permitting returning different values "
"depending on the search. The patterns are checked in order. The first match "
"is returned. Aliases: ``in_list()``, ``list_contains()``"
msgstr "``list_contains(value, separator, [ pattern, found_val, ]* not_found_val)`` -- (Alias de ``in_list``) Interprétant la valeur comme une liste d'éléments séparés par le ``separator``, évalue le ``pattern`` par rapport à chaque valeur de la liste. Si le ``pattern`` correspond à une valeur, il renvoie ``found_val``, sinon il renvoie ``not_found_val``. Le ``pattern`` et la ``found_value`` peuvent être répétés autant de fois que vous le souhaitez, ce qui permet de renvoyer différentes valeurs en fonction de la recherche. Les motifs sont vérifiés dans l'ordre. La première correspondance est retournée. Alias : ``in_list()``, ``list_contains()``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:534
msgid ""
"``list_count(value, separator)`` -- interprets ``value`` as a list of items "
"separated by ``separator``, returning the count of items in the list. "
"Aliases: ``count()``, ``list_count()``"
msgstr "``list_count(value, separator)`` -- interprète ``value`` comme une liste d'éléments séparés par ``separator``, et retourne le nombre d'éléments dans la liste. Alias : ``count()``, ``list_count()``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:535
msgid ""
"``list_count_matching(list, pattern, separator)`` -- interprets ``list`` as "
"a list of items separated by ``separator``, returning the number of items in"
" the list that match the regular expression ``pattern``. Aliases: "
"``list_count_matching()``, ``count_matching()``"
msgstr "``list_count_matching(list, pattern, separator)`` -- interprète ``list`` comme une liste d'éléments séparés par ``separator``, en retournant le nombre d'éléments dans la liste qui correspondent à l'expression régulière ``pattern``. Alias : ``list_count_matching()``, ``count_matching()``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:536
msgid ""
"``list_difference(list1, list2, separator)`` -- return a list made by "
"removing from ``list1`` any item found in ``list2`` using a case-insensitive"
" comparison. The items in ``list1`` and ``list2`` are separated by "
"separator, as are the items in the returned list."
msgstr "``list_difference(list1, list2, separator)`` -- restitue une liste en supprimant de ``list1`` tout élément trouvé dans ``list2 ``en utilisant une comparaison insensible à la casse. Les éléments dans ``list1`` et ``list2`` sont séparés par le séparateur, comme le sont les éléments dans la liste restituée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:537
msgid ""
"``list_equals(list1, sep1, list2, sep2, yes_val, no_val)`` -- return "
"``yes_val`` if ``list1`` and `list2` contain the same items, otherwise "
"return ``no_val``. The items are determined by splitting each list using the"
" appropriate separator character (``sep1`` or ``sep2``). The order of items "
"in the lists is not relevant. The comparison is case-insensitive."
msgstr "``list_equals(list1, sep1, list2, sep2, yes_val, no_val)`` --retourne ``yes_val`` si ``list1`` et ``list2`` contiennent les mêmes éléments, sinon renvoie ``no_val``. Les éléments sont déterminés en éclatant chaque liste à l’aide du séparateur approprié (``sep1`` ou ``sep2``). L’ordre des éléments dans la liste n’est pas pris en compte. La comparaison est insensible à la casse."

#: ../../__w/calibre/calibre/manual/template_lang.rst:538
msgid ""
"``list_intersection(list1, list2, separator)`` -- return a list made by "
"removing from ``list1`` any item not found in ``list2``, using a case-"
"insensitive comparison. The items in ``list1`` and ``list2`` are separated "
"by separator, as are the items in the returned list."
msgstr "``list_intersection(list1, list2, separator)`` -- retourne une liste faite en retirant de ``list1`` tout élément non trouvé dans ``list2``, en utilisant une comparaison insensible à la casse. Les éléments de ``list1`` et ``list2`` sont séparés par un séparateur, comme le sont les éléments de la liste retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:539
msgid ""
"``list_join(with_separator, list1, separator1 [, list2, separator2]*)`` -- "
"return a list made by joining the items in the source lists (``list1`` etc) "
"using ``with_separator`` between the items in the result list. Items in each"
" source ``list[123...]`` are separated by the associated "
"``separator[123...]``. A list can contain zero values. It can be a field "
"like ``publisher`` that is single-valued, effectively a one-item list. "
"Duplicates are removed using a case-insensitive comparison. Items are "
"returned in the order they appear in the source lists. If items on lists "
"differ only in letter case then the last is used. All separators can be more"
" than one character."
msgstr "``list_join(with_separator, list1, separator1 [, list2, separator2]*)`` -- retourne une liste faite en joignant les éléments des listes sources (``list1`` etc) en utilisant ``with_separator`` entre les éléments de la liste résultante. Les éléments de chaque ``liste[123...]`` source sont séparés par le ``séparateur[123...]`` associé. Une liste peut contenir zéro valeur. Il peut s'agir d'un champ comme ``publisher`` qui n'a qu'une seule valeur, c'est à dire une liste d'un seul élément. Les doublons sont supprimés en utilisant une comparaison insensible à la casse. Les éléments sont retournés dans l'ordre où ils apparaissent dans les listes sources. Si les éléments des listes ne diffèrent que par la casse des lettres, c'est la dernière qui est utilisée. Tous les séparateurs peuvent comporter plus d'un caractère."

#: ../../__w/calibre/calibre/manual/template_lang.rst:541
#: ../../__w/calibre/calibre/manual/template_lang.rst:563
msgid "Example::"
msgstr "Exemple::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:546
msgid ""
"You can use ``list_join`` on the results of previous calls to ``list_join`` "
"as follows::"
msgstr "Vous pouvez utiliser ``list_join`` sur les résultats des appels précédents à ``list_join`` comme suit ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:552
msgid ""
"You can use expressions to generate a list. For example, assume you want "
"items for ``authors`` and ``#genre``, but with the genre changed to the word"
" \"Genre: \" followed by the first letter of the genre, i.e. the genre "
"\"Fiction\" becomes \"Genre: F\". The following will do that::"
msgstr "Vous pouvez utiliser des expressions pour générer une liste. Par exemple, supposons que vous vouliez des éléments pour ``auteurs`` et ``#genre``, mais avec le genre changé en mot \"Genre : \" suivi de la première lettre du genre, c'est-à-dire que le genre \"Fiction\" devient \"Genre : F\". Ce qui suit fera l'affaire ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:557
msgid ""
"``list_re(src_list, separator, include_re, opt_replace)`` -- Construct a "
"list by first separating ``src_list`` into items using the ``separator`` "
"character. For each item in the list, check if it matches ``include_re``. If"
" it does then add it to the list to be returned. If ``opt_replace`` is not "
"the empty string then apply the replacement before adding the item to the "
"returned list."
msgstr "``list_re(src_list, separator, include_re, opt_replace)`` -- Construit une liste en séparant d'abord ``src_list`` en éléments en utilisant le caractère ``separator``. Pour chaque élément de la liste, vérifiez s'il correspond à ``include_re``. Si c'est le cas, ajoutez-le à la liste à retourner. Si ``opt_replace`` n'est pas une chaîne vide, il faut appliquer le remplacement avant d'ajouter l'élément à la liste retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:558
msgid ""
"``list_re_group(src_list, separator, include_re, search_re [, "
"template_for_group]*)`` -- Like list_re except replacements are not "
"optional. It uses ``re_group(item, search_re, template ...)`` when doing the"
" replacements."
msgstr "``list_re_group(src_list, separator, include_re, search_re [, template_for_group]*)`` -- Comme list_re sauf que les remplacements ne sont pas optionnels. Elle utilise ``re_group(item, search_re, template ...)`` pour effectuer les remplacements."

#: ../../__w/calibre/calibre/manual/template_lang.rst:559
msgid ""
"``list_remove_duplicates(list, separator)`` -- return a list made by "
"removing duplicate items in ``list``. If items differ only in case then the "
"last is returned. The items in ``list`` are separated by ``separator``, as "
"are the items in the returned list."
msgstr "``list_remove_duplicates(list, separator)`` -- retourne une liste faite en supprimant les éléments en double dans ``list``. Si les éléments ne diffèrent que par la casse, le dernier est retourné. Les éléments de ``list`` sont séparés par ``separator``, comme le sont les éléments de la liste retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:560
msgid ""
"``list_sort(list, direction, separator)`` -- return ``list`` sorted using a "
"case-insensitive lexical sort. If ``direction`` is zero, ``list`` is sorted "
"ascending, otherwise descending. The list items are separated by "
"``separator``, as are the items in the returned list."
msgstr "``list_sort(list, direction, separator)`` -- retourne ``list`` triée en utilisant un tri lexical insensible à la casse. Si ``direction`` est zéro, ``list`` est triée de manière ascendante, sinon de manière descendante. Les éléments de la liste sont séparés par le ``separator``, comme le sont les éléments de la liste retournée."

#: ../../__w/calibre/calibre/manual/template_lang.rst:561
msgid ""
"``list_split(list_val, sep, id_prefix)`` -- splits ``list_val`` into "
"separate values using ``sep``, then assigns the values to local variables "
"named ``id_prefix_N`` where N is the position of the value in the list. The "
"first item has position 0 (zero). The function returns the last element in "
"the list."
msgstr "``list_split(list_val, sep, id_prefix)`` -- divise ``list_val`` en valeurs séparées en utilisant ``sep``, puis affecte les valeurs à des variables locales nommées ``id_prefix_N`` où N est la position de la valeur dans la liste. Le premier élément a la position 0 (zéro). La fonction renvoie le dernier élément de la liste."

#: ../../__w/calibre/calibre/manual/template_lang.rst:567
msgid "is equivalent to::"
msgstr "est équivalent à ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:573
msgid ""
"``list_union(list1, list2, separator)`` -- return a list made by merging the"
" items in ``list1`` and ``list2``, removing duplicate items using a case-"
"insensitive comparison. If items differ in case, the one in ``list1`` is "
"used. The items in ``list1`` and ``list2`` are separated by ``separator``, "
"as are the items in the returned list. Aliases: ``merge_lists()``, "
"``list_union()``"
msgstr "``list_union(list1, list2, separator)`` -- retourne une liste faite en fusionnant les éléments de ``list1`` et ``list2``, en supprimant les éléments en double en utilisant une comparaison insensible à la casse. Si les éléments diffèrent selon la casse, c'est celui de la \"list1\" qui est utilisé. Les éléments de \"list1\" et \"list2\" sont séparés par un \"separator\", tout comme les éléments de la liste retournée. Alias : ``merge_lists()``, ``list_union()``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:574
msgid ""
"``mod(x, y)`` -- returns the ``floor`` of the remainder of ``x / y``. Throws"
" an exception if either ``x`` or ``y`` is not a number."
msgstr "``mod(x, y)`` -- renvoie le ``floor`` du reste de ``x / y``. Lance une exception si ``x`` ou ``y`` n'est pas un nombre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:575
msgid ""
"``multiply(x [, y]*)`` -- returns the product of its arguments. Throws an "
"exception if any argument is not a number. This function can usually be "
"replaced by the ``*`` operator."
msgstr "``multiply(x [, y]*)`` -- renvoie le produit de ses arguments. Lance une exception si l'un des arguments n'est pas un nombre. Cette fonction peut généralement être remplacée par l'opérateur ``*``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:576
msgid ""
"``not(value)`` -- returns the string \"1\" if the value is empty, otherwise "
"returns the empty string. This function can usually be replaced with the "
"unary not (``!``) operator."
msgstr "``not(valeur)`` -- retourne la chaîne \"1\" si la valeur est vide, sinon retourne la chaîne vide. Cette fonction peut généralement être remplacée par l'opérateur unaire not (``!``)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:577
msgid ""
"``ondevice()`` -- return the string ``'Yes'`` if ``ondevice`` is set, "
"otherwise return the empty string."
msgstr "``ondevice()`` -- retourne la chaîne ``Yes'`` si ``ondevice`` est défini, sinon retourne la chaîne vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:578
msgid ""
"``or(value [, value]*)`` -- returns the string ``'1'`` if any value is not "
"empty, otherwise returns the empty string. You can have as many values as "
"you want. This function can usually be replaced by the ``||`` operator. A "
"reason it cannot be replaced is if short-circuiting will change the results "
"because of side effects."
msgstr "``or(value [, value]*)`` -- retourne la chaîne ``'1'`` si une valeur n'est pas vide, sinon retourne la chaîne vide. Vous pouvez avoir autant de valeurs que vous le souhaitez. Cette fonction peut généralement être remplacée par l'opérateur ``||``. Une raison pour laquelle elle ne peut pas être remplacée est que le court-circuitage modifiera les résultats à cause d'effets secondaires."

#: ../../__w/calibre/calibre/manual/template_lang.rst:579
msgid ""
"``print(a [, b]*)`` -- prints the arguments to standard output. Unless you "
"start calibre from the command line (``calibre-debug -g``), the output will "
"go into a black hole. The ``print`` function always returns its first "
"argument."
msgstr "``print(a [, b]*)`` -- imprime les arguments sur la sortie standard. A moins que vous ne lanciez calibre depuis la ligne de commande (``calibre-debug -g``), la sortie ira dans un trou noir. La fonction ``print`` retourne toujours son premier argument."

#: ../../__w/calibre/calibre/manual/template_lang.rst:583
msgid ""
"``range(start, stop, step, limit)`` -- returns a list of numbers generated "
"by looping over the range specified by the parameters start, stop, and step,"
" with a maximum length of limit. The first value produced is 'start'. "
"Subsequent values ``next_v = current_v + step``. The loop continues while "
"``next_v < stop`` assuming ``step`` is positive, otherwise while ``next_v > "
"stop``. An empty list is produced if ``start`` fails the test: ``start >= "
"stop`` if ``step`` is positive. The ``limit`` sets the maximum length of the"
" list and has a default of 1000. The parameters ``start``, ``step``, and "
"``limit`` are optional. Calling ``range()`` with one argument specifies "
"``stop``. Two arguments specify ``start`` and ``stop``. Three arguments "
"specify ``start``, ``stop``, and ``step``. Four arguments specify ``start``,"
" ``stop``, ``step`` and ``limit``. Examples::"
msgstr "``range(start, stop, step, limit)`` -- renvoie une liste de nombres générés en bouclant sur la plage spécifiée par les paramètres start, stop, et step, avec une longueur maximale de limit. La première valeur produite est \"start\". Les valeurs suivantes sont ``next_v = current_v + step``. La boucle continue tant que ``next_v < stop`` si `step`` est positif, sinon tant que ``next_v > stop``. Une liste vide est produite si ``start`` échoue le test : ``start >= stop`` si ``step`` est positif. Le paramètre ``limit`` définit la longueur maximale de la liste et a une valeur par défaut de 1000. Les paramètres ``start``, ``step``, et ``limit`` sont facultatifs. Appeler ``range()`` avec un argument spécifie ``stop``. Deux arguments spécifient \" start \" et \" stop \". Trois arguments spécifient \" start \", \" stop \" et \" step \". Quatre arguments spécifient \" start \", \" stop \", \" step \" et \" limit \". Exemples ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:593
msgid ""
"``raw_field(lookup_name [, optional_default])`` -- returns the metadata "
"field named by ``lookup_name`` without applying any formatting. It evaluates"
" and returns the optional second argument ``optional_default`` if the "
"field's value is undefined (``None``)."
msgstr "``raw_field(lookup_name [, optional_default])`` -- renvoie le champ de métadonnées nommé par ``lookup_name`` sans appliquer de formatage. Il évalue et renvoie le second argument facultatif ``optional_default`` si la valeur du champ est indéfinie (``None``)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:594
msgid ""
"``raw_list(lookup_name, separator)`` -- returns the metadata list named by "
"``lookup_name`` without applying any formatting or sorting, with the items "
"separated by separator."
msgstr "``raw_list(lookup_name, separator)`` -- renvoie la liste de métadonnées nommée par ``lookup_name`` sans appliquer de formatage ou de tri, avec les éléments séparés par le séparateur."

#: ../../__w/calibre/calibre/manual/template_lang.rst:595
msgid ""
"``re_group(value, pattern [, template_for_group]*)`` --  return a string "
"made by applying the regular expression pattern to ``value`` and replacing "
"each matched instance with the the value returned by the corresponding "
"template. In :ref:`Template Program Mode <template_mode>`, like for the "
"``template`` and the ``eval`` functions, you use ``[[`` for ``{`` and ``]]``"
" for ``}``."
msgstr "``re_group(value, pattern [, template_for_group]*)`` -- renvoie une chaîne faite en appliquant le motif de l'expression régulière à ``value`` et en remplaçant chaque instance trouvée par la valeur renvoyée par le modèle correspondant. En :ref:`Mode Programme Modèle<template_mode>`, comme pour les fonctions ``template`` et ``eval``, vous utilisez `[[`` pour ``{`` et ``]]`` pour ``}``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:597
msgid ""
"The following example looks for a series with more than one word and "
"uppercases the first word::"
msgstr "L'exemple suivant recherche une série comportant plus d'un mot et met en majuscule le premier mot ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:601
msgid ""
"``round(x)`` -- returns the nearest integer to ``x``. Throws an exception if"
" ``x`` is not a number."
msgstr "``round(x)`` -- renvoie l'entier le plus proche de ``x``. Envoie une exception si ``x`` n'est pas un nombre."

#: ../../__w/calibre/calibre/manual/template_lang.rst:602
msgid "``series_sort()`` -- returns the series sort value."
msgstr "``series_sort()`` -- renvoie la valeur de tri des séries."

#: ../../__w/calibre/calibre/manual/template_lang.rst:603
msgid ""
"``strcat(a [, b]*)`` -- can take any number of arguments. Returns a string "
"formed by concatenating all the arguments."
msgstr "``strcat(a [, b]*)`` -- peut avoir n'importe quel nombre d’arguments. Renvoie une chaîne constituée par la concaténation de tous les arguments."

#: ../../__w/calibre/calibre/manual/template_lang.rst:604
msgid ""
"``strcat_max(max, string1 [, prefix2, string2]*)`` -- Returns a string "
"formed by concatenating the arguments. The returned value is initialized to "
"``string1``. Strings made from ``prefix, string`` pairs are added to the end"
" of the value as long as the resulting string length is less than ``max``. "
"Prefixes can be empty. Returns ``string1`` even if ``string1`` is longer "
"than ``max``. You can pass as many ``prefix, string`` pairs as you wish."
msgstr "``strcat_max(max, string1 [, prefix2, string2]*)`` -- Renvoie une chaîne formée par la concaténation des arguments. La valeur retournée est initialisée à ``string1``. Les chaînes formées à partir des paires ``prefix, string`` sont ajoutées à la fin de la valeur tant que la longueur de la chaîne résultante est inférieure à ``max``. Les préfixes peuvent être vides. Retourne ``string1`` même si ``string1`` est plus long que ``max``. Vous pouvez passer autant de paires ``prefix, string`` que vous le souhaitez."

#: ../../__w/calibre/calibre/manual/template_lang.rst:605
msgid ""
"``strcmp(x, y, lt, eq, gt)`` -- does a case-insensitive lexical comparison "
"of ``x`` and ``y``. Returns ``lt`` if ``x < y``, ``eq`` if ``x == y``, "
"otherwise ``gt``. This function can often be replaced by one of the lexical "
"comparison operators (``==``, ``>``, ``<``, etc.)"
msgstr "``strcmp(x, y, lt, eq, gt)`` -- effectue une comparaison lexicale insensible à la casse de ``x`` et ``y``. Elle retourne ``lt`` si ``x < y``, ``eq`` si ``x == y``, sinon ``gt``. Cette fonction peut souvent être remplacée par l'un des opérateurs de comparaison lexicale (``==``, ``>``, ``<``, etc.)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:606
msgid ""
"``strcmpcase(x, y, lt, eq, gt)`` -- does a case-sensitive lexical comparison"
" of ``x`` and ``y``. Returns ``lt`` if ``x < y``, ``eq`` if ``x == y``, "
"otherwise ``gt``."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:608
msgid ""
"Note: This is NOT the default behavior used by calibre, for example, in the "
"lexical comparison operators (``==``, ``>``, ``<``, etc.). This function "
"could cause unexpected results, preferably use ``strcmp()`` whenever "
"possible."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:610
msgid "``strlen(value)`` -- Returns the length of the string ``value``."
msgstr "``strlen( value)`` -- Retourne la longueur de la chaîne ``value``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:611
msgid ""
"``substr(str, start, end)`` -- returns the ``start``'th through the "
"``end``'th characters of ``str``. The first character in ``str`` is the "
"zero'th character. If ``end`` is negative, then it indicates that many "
"characters counting from the right. If ``end`` is zero, then it indicates "
"the last character. For example, ``substr('12345', 1, 0)`` returns "
"``'2345'``, and ``substr('12345', 1, -1)`` returns ``'234'``."
msgstr "``substr(str, start, end)`` -- renvoie les caractères de début jusqu'à fin de ``str``. Le premier caractère dans ``str`` est le caractère zéro. Si ``end`` est négatif, cela indique que beaucoup de caractères sont comptés à partir de la droite. Si end est zéro, cela indique le dernier caractère. Par exemple, ``substr('12345', 1, 0)`` renvoie ``'2345'``, et ``substr('12345', 1, -1)`` renvoie ``'234'``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:612
msgid ""
"``subtract(x, y)`` -- returns ``x - y``. Throws an exception if either ``x``"
" or ``y`` are not numbers. This function can usually be replaced by the "
"``-`` operator."
msgstr "``substract(x, y)`` -- renvoie ``x / y``. Lance une exception si ``x`` ou ``y`` ne sont pas des nombres. Cette fonction peut généralement être remplacée par l'opérateur ``-``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:613
msgid ""
"``switch_if([test_expression, value_expression,]+ else_expression)`` -- for "
"each ``test_expression, value_expression`` pair, checks if "
"``test_expression`` is True (non-empty) and if so returns the result of "
"``value_expression``. If no ``test_expression`` is True then the result of "
"``else_expression` is returned. You can have as many ``test_expression, "
"value_expression`` pairs as you want."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:614
msgid ""
"``today()`` -- return a date+time string for today (now). This value is "
"designed for use in `format_date` or `days_between`, but can be manipulated "
"like any other string. The date is in `ISO "
"<https://en.wikipedia.org/wiki/ISO_8601>`_ date/time format."
msgstr "``today()`` -- retourne une chaîne date+heure pour aujourd'hui (now). Cette valeur est conçue pour être utilisée dans `format_date` ou `days_between`, mais peut être manipulée comme toute autre chaîne. La date est au format `ISO `_ date/heure."

#: ../../__w/calibre/calibre/manual/template_lang.rst:615
msgid ""
"``template(x)`` -- evaluates ``x`` as a template. The evaluation is done in "
"its own context, meaning that variables are not shared between the caller "
"and the template evaluation."
msgstr "``template(x)`` -- évalue ``x`` comme un modèle. L'évaluation est faite dans son propre contexte, ce qui signifie que les variables ne sont pas partagées entre l'appelant et l'évaluation du modèle."

#: ../../__w/calibre/calibre/manual/template_lang.rst:616
msgid ""
"``to_hex(val)`` -- returns the string ``val`` encoded in hex. This is useful"
" when constructing calibre URLs."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:617
msgid ""
"``urls_from_identifiers(identifiers, sort_results)`` -- given a comma-"
"separated list of ``identifiers``, where an `identifier` is a colon-"
"separated pair of values (``id_name:id_value``), returns a comma-separated "
"list of HTML URLs generated from the identifiers. The list not sorted if "
"sort_results is ``0`` (character or number), otherwise it is sorted "
"alphabetically by the identifier name. The URLs are generated in the same "
"way as the built-in identifiers column when shown in :guilabel:`Book "
"details`."
msgstr "``urls_from_identifiers(identifiers, sort_results)`` -- donne une liste d'identifiants séparée par des virgules, où un identifiant est une paire de valeurs séparées par des deux points (``id_name:id_value``), renvoie une liste d'URL HTML séparées par des virgules, générées à partir des identifiants. La liste n'est pas triée si sort_results vaut ``0`` (caractère ou nombre), sinon elle est triée par ordre alphabétique du nom de l'identifiant. Les URL sont générées de la même manière que la colonne d'identifiants intégrée lorsqu'elle est affichée dans :guilabel:`Détails du livre`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:622
msgid "More complex programs in template expressions - Template Program Mode"
msgstr "Programmes plus complexes dans les expressions modèles - Mode Programme de Modèles"

#: ../../__w/calibre/calibre/manual/template_lang.rst:624
msgid ""
"`Template Program Mode` (`TPM`) is a blend of :ref:`General Program Mode "
"<general_mode>` and :ref:`Single Function Mode <single_mode>`. `TPM` differs"
" from Single Function Mode in that it permits writing template expressions "
"that refer to other metadata fields, use nested functions, modify variables,"
" and do arithmetic. It differs from `General Program Mode` in that the "
"template is contained between ``{`` and ``}`` characters and doesn't begin "
"with the word ``program:``. The program portion of the template is a General"
" Program Mode expression list."
msgstr "Le `Mode Programme de Modèle` (`MPM`) est un mélange du :ref:`Mode de Programme Général<general_mode>` et du :ref:`Mode Fonction Unique<single_mode>`. Le `MPM` diffère du Mode Fonction Unique en ce qu'il permet d'écrire des expressions de modèle qui font référence à d'autres champs de métadonnées, utilisent des fonctions imbriquées, modifient des variables et font de l'arithmétique. Il diffère du `Mode Programme Général` en ce que le modèle est contenu entre les caractères `{`` et ``}`` et ne commence pas par le mot ``program:``. La partie programme du modèle est une liste d'expressions du Mode Programme Général."

#: ../../__w/calibre/calibre/manual/template_lang.rst:627
msgid ""
"Example: assume you want a template to show the series for a book if it has "
"one, otherwise show the value of a custom field #genre. You cannot do this "
"in the :ref:`Single Function Mode <single_mode>` because you cannot make "
"reference to another metadata field within a template expression. In `TPM` "
"you can, as the following expression demonstrates::"
msgstr "Exemple : supposons que vous vouliez qu'un modèle affiche la série d'un livre s'il en a une, sinon la valeur d'un champ personnalisé #genre. Vous ne pouvez pas faire cela dans le mode :ref:`Mode Fonction Unique<single_mode>` car vous ne pouvez pas faire référence à un autre champ de métadonnées dans une expression de modèle. En `MPM`, vous le pouvez, comme le montre l'expression suivante ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:632
msgid "The example shows several things:"
msgstr "L'exemple montre plusieurs choses :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:634
msgid ""
"`TPM` is used if the expression begins with ``:'`` and ends with ``'}``. "
"Anything else is assumed to be in :ref:`Single Function Mode <single_mode>`."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:635
msgid ""
"the variable ``$`` stands for the field named in the template: the "
"expression is operating upon, ``#series`` in this case."
msgstr "la variable ``$`` représente le champ nommé dans le modèle : l'expression sur laquelle on opère, ``#series`` dans ce cas."

#: ../../__w/calibre/calibre/manual/template_lang.rst:636
msgid ""
"functions must be given all their arguments. There is no default value. For "
"example, the standard built-in functions must be given an additional initial"
" parameter indicating the source field."
msgstr "les fonctions doivent être données avec tous leurs arguments. Il n'y a pas de valeur par défaut. Par exemple, les fonctions intégrées standard doivent recevoir un paramètre initial supplémentaire indiquant le champ source."

#: ../../__w/calibre/calibre/manual/template_lang.rst:637
msgid "white space is ignored and can be used anywhere within the expression."
msgstr "les espaces sont ignorés et peuvent être utlisés n'importe où dans l'expression."

#: ../../__w/calibre/calibre/manual/template_lang.rst:638
msgid ""
"constant strings are enclosed in matching quotes, either ``'`` or ``\"``."
msgstr "les chaînes constantes sont entre guillemets, soit ``'`` ou ``\"``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:640
msgid ""
"All the functions listed under `Single Function Mode` and `General Program "
"Mode` can be used in `TPM`."
msgstr "Toutes les fonctions listées dans les rubriques `Mode Fonction Unique` et `Mode Programme Général` peuvent être utilisées dans le `MPM`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:642
msgid ""
"In `TPM`, using ``{`` and ``}`` characters in string literals can lead to "
"errors or unexpected results because they confuse the template processor. It"
" tries to treat them as template expression boundaries, not characters. In "
"some but not all cases you can replace a ``{`` with ``[[`` and a ``}`` with "
"`]]`. Generally, if your program contains ``{`` and ``}`` characters then "
"you should use `General Program Mode`."
msgstr "En `MPM`, l'utilisation des caractères `{`` et ``}`` dans les chaînes de caractères peut conduire à des erreurs ou des résultats inattendus parce qu'ils confondent le processeur de modèle. Il essaie de les traiter comme des limites d'expression de modèle et non comme des caractères. Dans certains cas, mais pas dans tous, vous pouvez remplacer un ``{`` par ``[[`` et un ``}`` par `]]`. En général, si votre programme contient des caractères ``{`` et ``}``, vous devriez utiliser le `Mode Programme Général`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:644
msgid ""
"As with `General Program Mode`, for functions documented under :ref:`Single "
"Function Mode <single_mode>` you must supply the value the function is to "
"act upon as the first parameter in addition to the documented parameters. In"
" `TPM` you can use ``$`` to access the value specified by the ``lookup "
"name`` for the template expression."
msgstr "Comme pour le `Mode Général de Programme`, pour les fonctions documentées sous :ref:`Mode Fonction Unique`, vous devez fournir la valeur sur laquelle la fonction doit agir comme premier paramètre en plus des paramètres documentés. En `MPM`, vous pouvez utiliser ``$`` pour accéder à la valeur spécifiée par le ``lookup name`` de l'expression modèle."

#: ../../__w/calibre/calibre/manual/template_lang.rst:649
msgid "Python Template Mode"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:651
msgid ""
"Python Template Mode (PTM) lets you write templates using native python and "
"the `calibre API <https://manual.calibre-ebook.com/develop.html#api-"
"documentation-for-various-parts-of-calibre>`_. The database API will be of "
"most use; further discussion is beyond the scope of this manual. PTM "
"templates are faster and can do more complicated operations but you must "
"know how to write code in python using the calibre API."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:653
msgid "A PTM template begins with:"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:671
msgid ""
"You can add the above text to your template using the context menu, usually "
"accessed with a right click. The comments are not significant and can be "
"removed. You must use python indenting."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:673
msgid ""
"The context object supports ``str(context)`` that returns a string of the "
"context's contents, and ``context.attributes`` that returns a list of the "
"attribute names in the context."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:675
msgid ""
"The ``context.funcs`` attribute allows calling Built-in and User template "
"functions, and Stored GPM/Python templates, so that you can execute them "
"directly in your code. The functions are retrieved using their names. If the"
" name conflicts with a Python keyword, add an underscore to the end of the "
"name. Examples:"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:682
msgid ""
"Here is an example of a PTM template that produces a list of all the authors"
" for a series. The list is stored in a `Column built from other columns, "
"behaves like tags`. It shows in :guilabel:`Book details` and has the "
":guilabel:`on separate lines` checked (in :guilabel:`Preferences->Look & "
"feel->Book details`). That option requires the list to be comma-separated. "
"To satisfy that requirement the template converts commas in author names to "
"semicolons then builds a comma-separated list of authors. The authors are "
"then sorted, which is why the template uses author_sort."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:703
msgid "The output in :guilabel:`Book details` looks like this:"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst-1
msgid "E-book conversion dialog"
msgstr "Dialogue de conversion des livres numériques"

#: ../../__w/calibre/calibre/manual/template_lang.rst:711
msgid "Stored templates"
msgstr "Modèles stockés"

#: ../../__w/calibre/calibre/manual/template_lang.rst:713
msgid ""
"Both :ref:`General Program Mode <general_mode>` and :ref:`Python Template "
"Mode <python_mode>` support saving templates and calling those templates "
"from another template, much like calling stored functions. You save "
"templates using :guilabel:`Preferences->Advanced->Template functions`. More "
"information is provided in that dialog. You call a template the same way you"
" call a function, passing positional arguments if desired. An argument can "
"be any expression. Examples of calling a template, assuming the stored "
"template is named ``foo``:"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:715
msgid "``foo()`` -- call the template passing no arguments."
msgstr "``foo()`` -- appelle le modèle en ne passant aucun argument."

#: ../../__w/calibre/calibre/manual/template_lang.rst:716
msgid ""
"``foo(a, b)`` call the template passing the values of the two variables "
"``a`` and ``b``."
msgstr "``foo(a, b)`` appelle le modèle en passant les valeurs des deux variables ``a`` et ``b``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:717
msgid ""
"``foo(if field('series') then field('series_index') else 0 fi)`` -- if the "
"book has a ``series`` then pass the ``series_index``, otherwise pass the "
"value ``0``."
msgstr "``foo(if field('series') then field('series_index') else 0 fi)`` -- si le livre a ``series`` alors passez le ``series_index``, sinon passez la valeur ``0``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:719
msgid ""
"In GPM you retrieve the arguments passed in the call to the stored template "
"using the ``arguments`` function. It both declares and initializes local "
"variables, effectively parameters. The variables are positional; they get "
"the value of the parameter given in the call in the same position. If the "
"corresponding parameter is not provided in the call then ``arguments`` "
"assigns that variable the provided default value. If there is no default "
"value then the variable is set to the empty string. For example, the "
"following ``arguments`` function declares 2 variables, ``key``, "
"``alternate``::"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:723
msgid "Examples, again assuming the stored template is named ``foo``:"
msgstr "Par exemple, en supposant encore une fois que le modèle stocké est nommé ``foo`` :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:725
msgid ""
"``foo('#myseries')`` -- argument ``key`` is assigned the value "
"``'myseries'`` and the argument ``alternate`` is assigned the default value "
"``'series'``."
msgstr "``foo('#myseries')`` -- l'argument ``key`` se voit attribuer la valeur ``myseries'`` et l'argument ``alternate`` se voit attribuer la valeur par défaut ``'series'``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:726
msgid ""
"``foo('series', '#genre')`` the variable ``key`` is assigned the value "
"``'series'`` and the variable ``alternate`` is assigned the value "
"``'#genre'``."
msgstr "``foo('series', '#genre')`` la variable ``key`` prend la valeur ``'series'`` et la variable ``alternate`` prend la valeur ``'#genre'``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:727
msgid ""
"``foo()`` -- the variable ``key`` is assigned the empty string and the "
"variable ``alternate`` is assigned the value ``'series'``."
msgstr "``foo()`` -- la variable ``key`` se voit attribuer la chaîne vide et la variable ``alternate`` se voit attribuer la valeur ``'series'``."

#: ../../__w/calibre/calibre/manual/template_lang.rst:729
msgid ""
"In PTM the arguments are passed in the ``arguments`` parameter, which is a "
"list of strings. There isn't any way to specify default values. You must "
"check the length of the ``arguments`` list to be sure that the number of "
"arguments is what you expect."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:731
msgid ""
"An easy way to test stored templates is using the ``Template tester`` "
"dialog. For ease of access give it a keyboard shortcut in "
":guilabel:`Preferences->Advanced->Keyboard shortcuts->Template tester`. "
"Giving the ``Stored templates`` dialog a shortcut will help switching more "
"rapidly between the tester and editing the stored template's source code."
msgstr "Une façon simple de tester les modèles stockés est d'utiliser le dialogue \"Testeur de modèle\". Pour faciliter l'accès, donnez-lui un raccourci clavier dans :guilabel:`Préférences->Avancé->Raccourcis clavier->Tester le modèle``. Donner un raccourci au dialogue ``Modèles stockés`` aidera à passer plus rapidement du testeur à l'édition du code source du modèle stocké."

#: ../../__w/calibre/calibre/manual/template_lang.rst:734
msgid "Providing additional information to templates"
msgstr "Fournir des informations supplémentaires aux modèles"

#: ../../__w/calibre/calibre/manual/template_lang.rst:736
msgid ""
"A developer can choose to pass additional information to the template "
"processor, such as application-specific book metadata or information about "
"what the processor is being asked to do. A template can access this "
"information and use it during the evaluation."
msgstr "Un développeur peut choisir de transmettre des informations supplémentaires au processeur du modèle, telles que des métadonnées de livre spécifiques à l'application ou des informations sur ce qui est demandé au processeur. Un modèle peut accéder à ces informations et les utiliser pendant l'évaluation."

#: ../../__w/calibre/calibre/manual/template_lang.rst:738
msgid "**Developer: how to pass additional information**"
msgstr "**Développeur : comment transmettre des informations supplémentaires**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:740
msgid ""
"The additional information is a Python dictionary containing pairs "
"``variable_name: variable_value`` where the values must be strings. The "
"template can access the dictionary, creating template local variables named "
"``variable_name`` containing the value ``variable_value``. The user cannot "
"change the name so it is best to use names that won't collide with other "
"template local variables, for example by prefixing the name with an "
"underscore."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:742
msgid ""
"This dictionary is passed to the template processor (the ``formatter``) "
"using the named parameter ``global_vars=your_dict``. The full method "
"signature is::"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:750
msgid "**Template writer: how to access the additional information**"
msgstr "**Rédacteur de modèles : comment accéder aux informations complémentaires**"

#: ../../__w/calibre/calibre/manual/template_lang.rst:752
msgid ""
"You access the additional information (the ``globals`` dictionary) in a "
"template using the template function::"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:756
msgid ""
"where ``id`` is any legal variable name. This function checks whether the "
"additional information provided by the developer contains the name. If it "
"does then the function assigns the provided value to a template local "
"variable with that name. If the name is not in the additional information "
"and if an ``expression`` is provided, the ``expression`` is evaluated and "
"the result is assigned to the local variable. If neither a value nor an "
"expression is provided, the function assigns the empty string (``''``) to "
"the local variable."
msgstr "où ``id`` est un nom de variable légale quelconque. Cette fonction vérifie si les informations supplémentaires fournies par le développeur contiennent le nom. Si c'est le cas, la fonction attribue la valeur fournie à une variable locale modèle avec ce nom. Si le nom ne figure pas dans les informations supplémentaires et si une \"expression\" est fournie, cette \"expression\" est évaluée et le résultat est attribué à la variable locale. Si ni une valeur ni une expression n'est fournie, la fonction attribue la chaîne vide (``''``) à la variable locale."

#: ../../__w/calibre/calibre/manual/template_lang.rst:758
msgid ""
"A template can set a value in the ``globals`` dictionary using the template "
"function::"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:762
msgid ""
"This function sets the ``globals`` dictionary key:value pair ``id:value`` "
"where ``value`` is the value of the template local variable ``id``. If that "
"local variable doesn't exist then ``value`` is set to the result of "
"evaluating ``expression``."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:765
msgid "Notes on the difference between modes"
msgstr "Notes sur la différence entre les modes"

#: ../../__w/calibre/calibre/manual/template_lang.rst:767
msgid ""
"The three program modes, :ref:`Single Function Mode <single_mode>` (SFM), "
":ref:`Template Program Mode <template_mode>` (`TPM`), and :ref:`General "
"Program Mode <general_mode>` (`GPM`), work differently. SFM is intended to "
"be 'simple' so it hides a lot of programming language bits."
msgstr "Les trois modes de programmation, :ref:`Mode Fonction Simple` (MFS), :ref:`Mode Modèle de Programmation` (`MMP`), et :ref:`Mode Général de Programmation` (`MGP`), fonctionnent différemment. Le MFS est destiné à être 'simple' et cache donc beaucoup de bits de langage de programmation."

#: ../../__w/calibre/calibre/manual/template_lang.rst:769
msgid "Differences:"
msgstr "Différences :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:771
msgid ""
"In SFM the value of the column is always passed as an 'invisible' first "
"argument to a function included in the template."
msgstr "Dans MFS, la valeur de la colonne est toujours passée comme premier argument 'invisible' à une fonction incluse dans le modèle."

#: ../../__w/calibre/calibre/manual/template_lang.rst:772
msgid ""
"SFM doesn't support the difference between variables and strings; all values"
" are strings."
msgstr "Le MFS ne supporte pas la différence entre les variables et les chaînes de caractères ; toutes les valeurs sont des chaînes de caractères."

#: ../../__w/calibre/calibre/manual/template_lang.rst:773
msgid ""
"The following SFM template returns either the series name or the string \"no"
" series\"::"
msgstr "Le modèle SFM suivant renvoie soit le nom de la série, soit la chaîne \"pas de série\" ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:777
msgid "The equivalent template in `TPM` is ::"
msgstr "Le modèle équivalent dans `MPM` est ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:781
msgid "The equivalent template in `GPM` is::"
msgstr "Le modèle équivalent dans `MGP` est ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:785
msgid ""
"The first argument to ``ifempty`` is the value of the field ``series``. The "
"second argument is the string ``no series``. In SFM the first argument, the "
"value of the field, is automatically passed (the invisible argument)."
msgstr "Le premier argument de ``ifempty`` est la valeur du champ ``série``. Le second argument est la chaîne ``no series``. Dans SFM, le premier argument, la valeur du champ, est automatiquement passé (l'argument invisible)."

#: ../../__w/calibre/calibre/manual/template_lang.rst:786
msgid ""
"Several template functions, for example ``booksize()`` and "
"``current_library_name()``, take no arguments. Because of the 'invisible "
"argument' you cannot use these functions in SFM."
msgstr "Plusieurs fonctions du modèle, par exemple ``booksize()`` et ``current_library_name()``, ne prennent aucun argument. En raison de l'\"argument invisible\", vous ne pouvez pas utiliser ces fonctions dans SFM."

#: ../../__w/calibre/calibre/manual/template_lang.rst:787
msgid ""
"Nested functions, where a function calls another function to compute an "
"argument, cannot be used in SFM. For example this template, intended to "
"return the first 5 characters of the series value uppercased, won't work in "
"SFM::"
msgstr "Les fonctions imbriquées, où une fonction appelle une autre fonction pour calculer un argument, ne peuvent pas être utilisées dans SFM. Par exemple, ce modèle, destiné à renvoyer les 5 premiers caractères de la valeur de la série en majuscules, ne fonctionnera pas dans SFM ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:791
msgid ""
"`TPM` and `GPM` support nested functions. The above template in `TPM` would "
"be::"
msgstr "`MPM` et `MPG` soutiennent des fonctions imbriquées. Le modèle ci-dessus dans `MPM` serait ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:795
msgid "In `GPM` it would be::"
msgstr "Dans `MPG`, ce serait ::"

#: ../../__w/calibre/calibre/manual/template_lang.rst:799
msgid ""
"As noted in the above :ref:`Template Program Mode <template_mode>` section, "
"using ``{`` and ``}`` characters in `TPM` string literals can lead to errors"
" or unexpected results because they confuse the template processor. It tries"
" to treat them as template boundaries, not characters. In some but not all "
"cases you can replace a ``{`` with ``[[`` and a ``}`` with `]]`. Generally, "
"if your program contains ``{`` and ``}`` characters then you should use "
"`General Program Mode`."
msgstr "Comme indiqué dans la section :ref:`Mode de Programmation des Modèles` ci-dessus, l'utilisation des caractères ``{`` et ``}`` dans les chaînes de caractères `MPM` peut conduire à des erreurs ou à des résultats inattendus car ils perturbent le processeur de modèles. Il essaie de les traiter comme des limites de modèles et non comme des caractères. Dans certains cas, mais pas dans tous, vous pouvez remplacer un ``{`` par ``[[`` et un ``}`` par ``]]`. En général, si votre programme contient des caractères ``{`` et ``}``, vous devriez utiliser le `Mode Général de Programmation`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:803
msgid "User-defined Python template functions"
msgstr "Fonctions des modèles Python définis par l'utilisateur"

#: ../../__w/calibre/calibre/manual/template_lang.rst:805
msgid ""
"You can add your own Python functions to the template processor. Such "
"functions can be used in any of the three template programming modes. The "
"functions are added by going to :guilabel:`Preferences -> Advanced -> "
"Template functions`. Instructions are shown in that dialog."
msgstr "Vous pouvez ajouter vos propres fonctions Python au processeur de modèles. Ces fonctions peuvent être utilisées dans l'un des trois modes de programmation du modèle. Les fonctions sont ajoutées en allant dans :guilabel:`Préférences -> Avancé -> Fonctions de modèle`. Les instructions sont affichées dans cette boite de dialogue."

#: ../../__w/calibre/calibre/manual/template_lang.rst:808
msgid "Special notes for save/send templates"
msgstr "Notes spéciales pour la sauvergarde/l'envoi des modèles"

#: ../../__w/calibre/calibre/manual/template_lang.rst:810
msgid ""
"Special processing is applied when a template is used in a `save to disk` or"
" `send to device` template. The values of the fields are cleaned, replacing "
"characters that are special to file systems with underscores, including "
"slashes. This means that field text cannot be used to create folders. "
"However, slashes are not changed in prefix or suffix strings, so slashes in "
"these strings will cause folders to be created. Because of this, you can "
"create variable-depth folder structure."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:812
msgid ""
"For example, assume we want the folder structure `series/series_index - "
"title`, with the caveat that if series does not exist, then the title should"
" be in the top folder. The template to do this is::"
msgstr "Par exemple, supposons que nous voulons que la structure des dossiers soit `series/series_index - titre`, en prévoyant que si la série n'existe pas, alors le titre devrait être dans le dossier racine (le premier dossier, pas le sous-dossier). Le modèle pour faire cela est :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:816
msgid "The slash and the hyphen appear only if series is not empty."
msgstr "La barre oblique et le trait d'union apparaissent uniquement si la série n'est pas vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:818
msgid ""
"The lookup function lets us do even fancier processing. For example, assume "
"that if a book has a series, then we want the folder structure "
"`series/series index - title.fmt`. If the book does not have a series then "
"we want the folder structure `genre/author_sort/title.fmt`. If the book has "
"no genre then we want to use 'Unknown'. We want two completely different "
"paths, depending on the value of series."
msgstr "La fonction de recherche nous permet de faire le traitement encore plus poussé. Par exemple, supposons que si un livre est dans une série, alors nous voulons que la structure soit la suivante : `series/series index - title.fmt`.. Si le livre n'est pas dans une série, alors nous voulons que la structure des dossiers soit  `genre/author_sort/title.fmt`. Si le livre n'a pas de genre, alors nous voulons utiliser 'Inconnu'. Nous voulons deux chemins de répertoire totalement différents en fonction de la valeur de la série."

#: ../../__w/calibre/calibre/manual/template_lang.rst:820
msgid "To accomplish this, we:"
msgstr "Pour accomplir cela, nous :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:822
msgid ""
"Create a composite field (give it lookup name #aa) containing "
"``{series}/{series_index} - {title}``. If the series is not empty, then this"
" template will produce `series/series_index - title`."
msgstr "Créer un champ composite (donner-lui le nom de recherche #aa) contenant ``{series}/{series_index} - {titre}``. Si la série n'est pas vide, alors ce modèle produira `series/series_index - titre`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:823
msgid ""
"Create a composite field (give it lookup name #bb) containing "
"``{#genre:ifempty(Unknown)}/{author_sort}/{title}``. This template produces "
"`genre/author_sort/title`, where an empty genre is replaced with `Unknown`."
msgstr "Créons une champ composite (appelons-le #bb) contenant ``{#genre:ifempty(Unknown)}/{author_sort}/{title}``. Ce modèle produit `genre/author_sort/title`, où un genre vide est remplacé par `Inconnu`."

#: ../../__w/calibre/calibre/manual/template_lang.rst:824
msgid ""
"Set the save template to ``{series:lookup(.,#aa,#bb}``. This template "
"chooses composite field ``#aa`` if series is not empty and composite field "
"``#bb`` if series is empty. We therefore have two completely different save "
"paths, depending on whether or not `series` is empty."
msgstr "Paramétrez le modèle de sauvegarde à ``{series:lookup(.,#aa,#bb)}``. Ce modèle choisit le champ composite ``#aa`` si série n'est pas vide, et le champ composite ``#bb`` si série est vide. Nous avons dès lors deux chemins de sauvegarde complètement différents, dépendant du fait que `series` soit vide ou pas."

#: ../../__w/calibre/calibre/manual/template_lang.rst:827
msgid "Templates and plugboards"
msgstr "Modèles et tableaux de connexions"

#: ../../__w/calibre/calibre/manual/template_lang.rst:829
msgid ""
"Plugboards are used for changing the metadata written into books during "
"send-to-device and save-to-disk operations. A plugboard permits you to "
"specify a template to provide the data to write into the book's metadata. "
"You can use plugboards to modify the following fields: authors, author_sort,"
" language, publisher, tags, title, title_sort. This feature helps people who"
" want to use different metadata in books on devices to solve sorting or "
"display issues."
msgstr "Les tableaux de connexions sont utilisés pour modifier les métadonnées écrites dans les livres pendant l'envoi à une liseuse et les opérations de sauvegarde sur le disque. Le tableau de connexion vous permet de spécifier pour un modèle de lecteur précis quelles données à insérer dans les métadonnées du livre. Vous pouvez utiliser les tableaux de connexions pour modifier les champs suivants : authors, author_sort, language, publisher, tags, title, title_sort. Cette fonctionnalité aide ceux qui veulent utiliser les différentes métadonnées des livres pour contrôler le tri ou l'affichage des livres sur leurs périphériques."

#: ../../__w/calibre/calibre/manual/template_lang.rst:831
msgid ""
"When you create a plugboard, you specify the format and device for which the"
" plugboard is to be used. A special device is provided, ``save_to_disk``, "
"that is used when saving formats (as opposed to sending them to a device). "
"Once you have chosen the format and device, you choose the metadata fields "
"to change, providing templates to supply the new values. These templates are"
" `connected` to their destination fields, hence the name `plugboards`. You "
"can of course use composite columns in these templates."
msgstr "Lorsque vous créez un tableau de connexion, vous spécifiez le format et le périphérique pour lequel le tableau de connexion doit être utilisé. Un périphérique spécial est procuré, ``save_to_disk`` qui est utilisé lors de la sauvegarde de formats (en opposition à les envoyer vers le périphérique). Une fois que vous avez choisi le format et le périphérique, vous choisissez les champs de métadonnées à modifier, indiquez le modèle à appliquer pour fournir les nouvelles valeurs. Ces modèles sont `reliés` à leurs champs de destination, d'où le nom de `tableau de connexions`. Vous pouvez bien sûr utiliser des colonnes composites dans ces modèles."

#: ../../__w/calibre/calibre/manual/template_lang.rst:833
msgid ""
"When a plugboard might apply (Content server, save to disk, or send to "
"device), calibre searches the defined plugboards to choose the correct one "
"for the given format and device. For example, to find the appropriate "
"plugboard for an EPUB book being sent to an ANDROID device, calibre searches"
" the plugboards using the following search order:"
msgstr "Quand un tableau de connexion doit s'appliquer (Serveur de contenu, sauvegarde sur disque ou envoyer au périphérique), calibre recherche les tableau de connexions définis et celui qui est correct pour le format donné et le périphérique. Par exemple, pour trouver le tableau de connexion approprié pour un livre EPUB envoyé à un périphérique ANDROID, calibre recherche dans les tableaux de connexion dans l'ordre de recherche suivant :"

#: ../../__w/calibre/calibre/manual/template_lang.rst:837
msgid ""
"a plugboard with an exact match on format and device, e.g., ``EPUB`` and "
"``ANDROID``"
msgstr "un tableau de connexion avec une correspondance exacte sur le format et le périphérique, par ex., ``EPUB`` et ``ANDROID``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:838
msgid ""
"a plugboard with an exact match on format and the special ``any device`` "
"choice, e.g., ``EPUB`` and ``any device``"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:839
msgid ""
"a plugboard with the special ``any format`` choice and an exact match on "
"device, e.g., ``any format`` and ``ANDROID``"
msgstr "un tableau de connexion avec le choix spécial ``n'importe quel format`` et une correspondance exacte sur le périphérique, par ex., ``n'importe quel format`` et ``ANDROID``"

#: ../../__w/calibre/calibre/manual/template_lang.rst:840
msgid "a plugboard with ``any format`` and ``any device``"
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:842
msgid ""
"The tags and authors fields have special treatment, because both of these "
"fields can hold more than one item. A book can have many tags and many "
"authors. When you specify that one of these two fields is to be changed, the"
" template's result is examined to see if more than one item is there. For "
"tags, the result is cut apart wherever calibre finds a comma. For example, "
"if the template produces the value ``Thriller, Horror``, then the result "
"will be two tags, ``Thriller`` and ``Horror``. There is no way to put a "
"comma in the middle of a tag."
msgstr "Les étiquettes et les champs auteur ont un traitement spécial, parce que ces deux champs peuvent contenir plusieurs données. Un livre peut avoir plusieurs étiquettes et plusieurs auteurs. Lorsque vous spécifiez que l'un de ces deux champs doit être modifié, le résultat du modèle est examiné pour voir s'il y a plus d'un élément dedans. Pour les étiquettes, le résultat est découpé partout où calibre trouve une virgule. Par exemple, si le modèle produit les valeurs ``Thriller, Horreur``, alors ke résultat sera deux étiquettes, ``Thriller`` et ``Horreur``. Il n'est pas possible de mettre une virgule au milieu d'une étiquette."

#: ../../__w/calibre/calibre/manual/template_lang.rst:845
msgid ""
"The same thing happens for authors, but using a different character for the "
"cut, a `&` (ampersand) instead of a comma. For example, if the template "
"produces the value ``Blogs, Joe&Posts, Susan``, then the book will end up "
"with two authors, ``Blogs, Joe`` and ``Posts, Susan``. If the template "
"produces the value ``Blogs, Joe;Posts, Susan``, then the book will have one "
"author with a rather strange name."
msgstr "La même chose se produit pour les auteurs, mais en utilisant un caractère différent comme séparateur, le `&` (esperluette) au lieu d'une virgule. Par exemple, si le modèle produit la valeur ``Blogs, Joe&Posts, Susan``, alors le livre finira avec deux auteurs ``Blogs, Joe`` et ``Posts, Susan``. Si le modèle produit la valeur ``Blogs, Joe;Posts, Susan``, alors ce livre aura un auteur avec un nom assez étrange."

#: ../../__w/calibre/calibre/manual/template_lang.rst:847
msgid ""
"Plugboards affect the metadata written into the book when it is saved to "
"disk or written to the device. Plugboards do not affect the metadata used by"
" ``save to disk`` and ``send to device`` to create the file names. Instead, "
"file names are constructed using the templates entered on the appropriate "
"preferences window."
msgstr ""

#: ../../__w/calibre/calibre/manual/template_lang.rst:850
msgid "Tips"
msgstr "Astuces"

#: ../../__w/calibre/calibre/manual/template_lang.rst:852
msgid ""
"Use the Template Tester to test templates. Add the tester to the context "
"menu for books in the library and/or give it a keyboard shortcut."
msgstr "Utilisez le Testeur de Modèles pour tester les modèles. Ajoutez le testeur au menu contextuel des livres de la bibliothèque et/ou donnez-lui un raccourci clavier."

#: ../../__w/calibre/calibre/manual/template_lang.rst:853
msgid ""
"Templates can use other templates by referencing composite columns built "
"with the desired template. Alternatively, you can use Stored Templates."
msgstr "Les modèles peuvent utiliser d'autres modèles en faisant référence à des colonnes composites construites avec le modèle souhaité. Vous pouvez également utiliser des Modèles Stockés comme alternative."

#: ../../__w/calibre/calibre/manual/template_lang.rst:854
msgid ""
"In a plugboard, you can set a field to empty (or whatever is equivalent to "
"empty) by using the special template ``{}``. This template will always "
"evaluate to an empty string."
msgstr "Dans un tableau de connexions, vous pouvez paramétrer un champ à vide (ou quelque soit sont équivalent à vide) en utilisant le modèle spécial ``{}``. Ce modèle sera toujours évalué à une chaîne vide."

#: ../../__w/calibre/calibre/manual/template_lang.rst:855
msgid ""
"The technique described above to show numbers even if they have a zero value"
" works with the standard field series_index."
msgstr "La technique indiquée ci-dessus pour montrer les nombre même s'ils ont une valeur zéro fonctionne avec le champ standard series_index."

#: ../../__w/calibre/calibre/manual/template_lang.rst:860
msgid "Function reference"
msgstr "Référence de la fonction"
