calibre - en to fr translation catalogue (260 entries)

en: The calibre template language
fr: Le langage de modèle calibre

en: 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:
fr: 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 :

en: Specify the folder structure and file names when saving files from the calibre library to the disk or e-book reader.
fr: 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.

en: Define rules for adding icons and colors to the calibre book list.
fr: Définir des règles pour l'ajout d'icônes et de couleurs à la liste de livres de calibre.

en: Define `virtual columns` that contain data from other columns.
fr: Définir les `colonnes virtuelles` qui contiennent des données provenant d'autres colonnes.

en: Advanced library searching.
fr: Recherche avancée dans la bibliothèque.

en: Advanced metadata search and replace.
fr: Recherche et remplacement avancé des métadonnées.

en: 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.
fr: 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.

en: Basic templates
fr: Modèles de base

en: 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``::
fr: 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``::

en: For the book "The Foundation" by "Isaac Asimov" the  will become::
fr: Pour le livre "The Foundation" par "Isaac Asimov" cela donnera::

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

en: then for "The Foundation" the template produces::
fr: dès lors, pour "The Foundation", le modèle produit::

en: 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``.
fr: 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``.

en: In addition to the standard column based fields, you also can use:
fr: En plus des champs standard basés sur des colonnes, vous pouvez également utiliser :

en: ``{formats}`` - A list of formats available in the calibre library for a book
fr: ``{formats}`` - Une liste des formats disponibles dans la bibliothèque calibre pour un livre

en: ``{identifiers:select(isbn)}`` - The ISBN of the book
fr: ``{identifiers:select(isbn)}`` - L'ISBN du livre

en: 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::
fr: 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 ::

en: If Asimov's book "Second Foundation" is in the series "Foundation" then the template produces::
fr: Si le livre d'Asimov "Seconde Fondation" fait partie de la série "Fondation", alors le modèle produit ::

en: If a series has not been entered for the book then the template produces::
fr: Si aucune série n'a été saisie pour le livre, le modèle produit ::

en: The template processor automatically removes multiple slashes and leading or trailing spaces.
fr: Le processeur de modèles supprime automatiquement les barres obliques multiples et les espaces avant ou arrière.

en: Advanced formatting
fr: Mise en forme avancée

en: In addition to metadata substitution, templates can conditionally include additional text and control how substituted data is formatted.
fr: 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.

en: **Conditionally including text**
fr: **Comprenant conditionnellement le texte**

en: 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.
fr: 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``.

en: For example and using the above Foundation example, assume you want the template to produce `Foundation - 3 - Second Foundation`. This template produces that output:
fr: 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 :

en: 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:
fr: 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 :

en: 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.
fr: 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.

en: **Do not use subtemplates (`{ ... }`) or functions (see below) in the prefix or the suffix.**
fr: **Ne pas utiliser de sous-modèles (`{ ... }`) ou de fonctions (voir ci-dessous) dans le préfixe ou le suffixe.**

en: Using this syntax, we can solve the above no-series problem with the template::
fr: En utilisant cette syntaxe, nous pouvons résoudre le problème de non-série ci-dessus avec le modèle ::

en: 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`.
fr: 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`.

en: Notes:
fr: Notes :

en: You must include the colon after the ``lookup name`` if you are using a prefix or a suffix.
fr: Vous devez inclure les deux points après le ``nom de la recherche`` si vous utilisez un préfixe ou un suffixe.

en: You must either use either no or both ``|`` characters. Using one, as in ``{field:| - }``, is not allowed.
fr: 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.

en: 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}``.
fr: 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}``.

en: **Formatting**
fr: **Formatage**

en: Suppose you want the ``series_index`` to be formatted as three digits with leading zeros. This does the trick:
fr: Supposons que vous vouliez que ``series_index`` soit formaté en trois chiffres avec des zéros en tête. Ceci fait l'affaire :

en: ``{series_index:0>3s}`` - Three digits with leading zeros
fr: ``{series_index:0>3s}`` - Trois chiffres avec des zéros en tête

en: For trailing zeros, use:
fr: Pour des zéros qui suivent, utilisez:

en: ``{series_index:0<3s}`` - Three digits with trailing zeros
fr: ``{series_index:0>3s}`` - Trois chiffres avec des zéros qui suivent

en: 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:
fr: 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 :

en: ``{series_index:0>5.2f}`` - Five characters consisting of two digits with leading zeros, a decimal point, then 2 digits after the decimal point.
fr: ``{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.

en: If you want only the first two letters of the data, use:
fr: Si vous ne voulez que les deux premières lettres de la donnée, utilisez :

en: ``{author_sort:.2}`` - Only the first two letters of the author sort name
fr: ``{author_sort :.2}`` - Seulement les deux premières lettres du nom de tri de l'auteur

en: 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>`_.
fr: 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>`

en: Using templates to define custom columns
fr: Utilisation de modèles pour définir des colonnes personnalisées

en: 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}``.
fr: 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}``.

en: Composite columns can use any template option, including formatting.
fr: Les colonnes composites peuvent utiliser n'importe quelle option modèle, y compris le formatage.

en: 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.
fr: 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.

en: Templates and plugboards
fr: Modèles et tableaux de connexions

en: 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.
fr: 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.

en: 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.
fr: 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.

en: Plugboards are quite flexible and can be written in Single Function Mode, Template Program Mode, General Program Mode, or Python Template mode.
fr: Les tableaux de connexions sont assez flexibles et peuvent être écrits en mode fonction unique, en mode programme modèle, en mode programme général ou en mode modèle Python.

en: 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:
fr: 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 :

en: a plugboard with an exact match on format and device, e.g., ``EPUB`` and ``ANDROID``
fr: un tableau de connexion avec une correspondance exacte sur le format et le périphérique, par ex., ``EPUB`` et ``ANDROID``

en: a plugboard with an exact match on format and the special ``any device`` choice, e.g., ``EPUB`` and ``any device``
fr: un tableau de connexion avec une correspondance exacte sur le format et le choix spécial ``n'importe quel périphérique``, par ex., ``EPUB`` et ``n'importe quel périphérique``

en: a plugboard with the special ``any format`` choice and an exact match on device, e.g., ``any format`` and ``ANDROID``
fr: 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``

en: a plugboard with ``any format`` and ``any device``
fr: un tableau de conversion avec ``n'importe quel format`` et ``n'importe quel périphérique``

en: 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.
fr: 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.

en: 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.
fr: 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.

en: 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.
fr: Les tableaux de connexions affectent les métadonnées écrites dans le livre quand il est sauvegardé sur le disque ou copié sur le périphérique. Les tableaux de connexions n'affecte pas les métadonnées utilisées par ``Enregistrer sur le disque`` et ``Envoyer au périphérique``. A la place, les noms de fichiers sont construits en utilisant les modèles entrés dans la fenêtre de préférence appropriée.

en: Using functions in templates - Single Function Mode
fr: Utilisation des fonctions dans les modèles - Mode de fonctionnement unique

en: 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()}``.
fr: 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()}``.

en: 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.
fr: 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.

en: The syntax for using functions is one of::
fr: La syntaxe pour utiliser les fonctions est l'une des suivantes ::

en: 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.
fr: 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.

en: Functions are evaluated before format specifications and the prefix/suffix. See further down for an example of using both a format and a function.
fr: 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.

en: **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.
fr: **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.

en: **Do not use subtemplates (`{ ... }`) as function arguments.** Instead, use :ref:`Template Program Mode <template_mode>` and :ref:`General Program Mode <general_mode>`.
fr: **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`.

en: Notes on calling functions in Single Function Mode:
fr: Notes sur l'appel de fonctions en Mode Fonction Unique :

en: When functions are used in Single Function Mode, the first parameter, ``value``, is automatically replaced by the content of the field specified in the template. For example, when the template ``{title:capitalize()}`` is processed, the content of the ``title`` field is passed as the parameter ``value`` to the capitalize function.
fr: Lorsque les fonctions sont utilisées en Mode Fonction Unique, le premier paramètre, ``value``, est automatiquement remplacé par le contenu du champ spécifié dans le modèle. Par exemple, lorsque le modèle ``{title:capitalize()}`` est traité, le contenu du champ ``title`` est passé comme paramètre ``value`` à la fonction capitalize.

en: In the function documentation, 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).
fr: Dans la documentation des fonctions, 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).

en: Some functions use regular expressions. In the template language regular expression matching is case-insensitive.
fr: Certaines fonctions utilise des expressions régulières. Dans le langage des modèles, la correspondance des expressions régulières est insensible à la casse.

en: Functions are documented in :ref:`template_functions_reference`. The documentation tells you what arguments the functions require and what the functions do. For example, here is the documentation of the :ref:`ff_ifempty` function.
fr: Les fonctions sont documentées dans :ref:`template_functions_reference`. La documentation vous indique les arguments requis par les fonctions et ce qu'elles font. Par exemple, voici la documentation de la fonction :ref:`ff_ifempty`.

en: You see that the function requires two arguments, ``value`` and ``text_if_empty``. However, because we are using Single Function Mode, we omit the ``value`` argument, passing only ``text_if_empty``. For example, this template::
fr: Vous voyez que la fonction requiert deux arguments, ``value`` et ``text_if_empty``. Cependant, parce que nous utilisons le Mode Fonction Unique, nous omettons l'argument ``value``, en ne passant que ``text_if_empty``. Par exemple, ce modèle ::

en: shows the tags for a book, if any. If it has no tags then it show `No tags on this book`.
fr: affiche les étiquettes d'un livre, s'il y en a. Si le livre n'a pas d'étiquettes, il affiche `Aucune étiquette sur ce livre`.

en: The following functions are usable in Single Function Mode because their first parameter is ``value``.
fr: Les fonctions suivantes sont utilisable en Mode Fonction Unique car leur premier paramètre est ``value``.

en: **Using functions and formatting in the same template**
fr: **Utilisation des fonctions et du formatage dans le même modèle**

en: 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::
fr: 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 ::

en: 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::
fr: 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 ::

en: General Program Mode
fr: Mode Programme Général

en: `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::
fr: 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 ::

en: 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``.
fr: 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``.

en: In a logical context, any non-empty value is ``True``
fr: Dans un contexte logique, toute valeur non vide est ``True``.

en: In a logical context, the empty value is ``False``
fr: Dans un contexte logique, la valeur vide est ``False``.

en: Strings and numbers can be used interchangeably. For example, ``10`` and ``'10'`` are the same thing.
fr: 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.

en: Comments are lines starting with a '#' character, possibly preceded by blanks or tabs.
fr: Les commentaires sont des lignes commençant par le caractère "#", commençant éventuellement pars des espace ou des tabulation.

en: **Operator precedence**
fr: **Préséance de l'opérateur**

en: The operator precedence (order of evaluation) from highest (evaluated first) to lowest (evaluated last) is:
fr: 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 :

en: Function calls, constants, parenthesized expressions, statement expressions, assignment expressions, field references.
fr: Appels de fonctions, constantes, expressions entre parenthèses, expressions d'instructions, expressions d'affectation, références de champs.

en: Unary plus (``+``) and minus (``-``). These operators evaluate right to left.
fr: Les opérateurs unaires plus (``+``) et moins (``-``). Ces opérateurs s'évaluent de droite à gauche.

en: 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``.
fr: 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``.

en: Multiply (``*``) and divide (``/``). These operators are associative and evaluate left to right. Use parentheses if you want to change the order of evaluation.
fr: 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.

en: Add (``+``) and subtract (``-``). These operators are associative and evaluate left to right.
fr: Additionner (``+``) et soustraire (``-``). Ces opérateurs sont associatifs et s'évaluent de gauche à droite.

en: 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.
fr: 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.

en: 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.
fr: 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.

en: Unary logical not (``!``). This operator returns ``'1'`` if the expression is False (evaluates to the empty string), otherwise ``''``.
fr: Unaire non logique (``!``). Cet opérateur renvoie ``'1'`` si l'expression est fausse (évaluée à la chaîne vide), sinon ``''``.

en: 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>`_.
fr: 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>`_.

en: 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.
fr: 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.

en: **Field references**
fr: **Références des champs**

en: 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 :ref:`ff_field` function. Using ``$$`` is equivalent to using the :ref:`ff_raw_field` function. Examples::
fr: 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 `:ref:`ff_field`. L'utilisation de ``$$`` équivaut à l'utilisation de la fonction :ref:`ff_raw_field`. Exemples ::

en: **If expressions**
fr: **Expressions if**

en: ``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.
fr: 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.

en: Examples::
fr: Exemples::

en: Nested ``if`` example::
fr: Exemple de ``if`` imbriqué::

en: As said above, an ``if`` produces a value. This means that all the following are equivalent::
fr: Comme dit plus haut, un ``if`` produit une valeur. Cela signifie que tous les cas suivants sont équivalents ::

en: For example, this program returns the value of the ``series`` column if the book has a series, otherwise the value of the ``title`` column::
fr: Par exemple, ce programme retourne la valeur de la colonne ``series`` si le livre a une série, sinon la valeur de la colonne ``title`` ::

en: **For expressions**
fr: **Expressions for**

en: 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:`ff_range` 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.
fr: 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 :ref:`ff_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.

en: Example: This template removes the first hierarchical name for each value in Genre (``#genre``), constructing a list with the new names::
fr: 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 ::

en: 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.
fr: 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.

en: 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``.
fr: 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``.

en: **Return stmt**
fr: **Déclaration return**

en: Return the value of the ``expression``. If executed in a function then it returns the value of the expression to the caller. If executed in the outermost context (the template) then it sets the value of the template to the value of the expression and exits the template.
fr: Retourne la valeur de l'``expression``. Si est exécutée dans une fonction, retourne la valeur de l'expression à l'appelant. Si est exécutée dans le contexte le plus externe (le modèle), définit la valeur du modèle à la valeur de l'expression et quitte le modèle.

en: **Function definition**
fr: **Définition de la fonction**

en: If you have repeated code in a template 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.
fr: Si vous avez répète du code dans un modèle, 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``.

en: 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.
fr: 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.

en: The ``return`` statement can be used in a local function.
fr: L'instruction ``return`` peut être utilisée dans une fonction locale.

en: A function must be defined before it can be used.
fr: Une fonction doit être définie avant de pouvoir être utilisée.

en: 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::
fr: 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 ``&``::

en: **Relational operators**
fr: **Opérateurs relationnels**

en: Relational operators return ``'1'`` if the comparison is true, otherwise the empty string (``''``).
fr: Les opérateurs relationnels retourne ``'1'`` si la comparaison est vraie, sinon la chaîne vide (``''``).

en: There are two forms of relational operators: string comparisons and numeric comparisons.
fr: Il existe deux formes d'opérateurs relationnels : les comparaisons de chaînes de caractères et les comparaisons numériques.

en: String comparisons do case-insensitive string comparison using lexical order. The supported string comparison operators are ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``, ``in``, ``inlist``, and ``inlist_field``. For the ``in``, ``inlist``, and ``inlist_field`` operators, the result of the left hand expression is interpreted as a regular expression pattern. They are true if the value of left-hand regular expression matches the value of the right hand expression. The regular expressions are case-insensitive.
fr: 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 pris en charge sont ``==``, ``!=``, ``<``, ``<=``, ``>``, ``=``, ``in``, ``inlist`` et ``inlist_field``. Pour les opérateurs ``in``, ``inlist`` et ``inlist_field``, le résultat de l'expression de gauche est interprété comme un motif d'expression régulière. Les opérateurs sont True si la valeur de l'expression régulière de gauche correspond à la valeur de l'expression de droite. Les expressions régulières sont insensibles à la casse.

en: 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 ``inlist_field`` operator is true if the left hand regular expression matches any of the items in the field (column) named by the right hand expression, using the separator defined for the field. NB: the ``inlist_field`` operator requires the right hand expression to evaluate to a field name, while the ``inlist`` operator requires the right hand expression to evaluate to a string containing a comma-separated list. Because of this difference, ``inlist_field`` is substantially faster than ``inlist`` because no string conversions or list constructions are done.
fr: 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 où les éléments de la liste sont séparés par des virgules. L'opérateur ``inlist_field`` est vrai si l'expression régulière de gauche correspond à l'un des éléments du champ (colonne) nommé par l'expression de droite, en utilisant le séparateur défini pour le champ. NB : l'opérateur ``inlist_field`` requiert que l'expression de droite sui est évaluée soit un nom de champ, alors que l'opérateur ``inlist`` requiert que l'expression de droite qui est évaluée soit une chaîne de caractères contenant une liste séparée par des virgules. A cause de cette différence, ``inlist_field`` est substantiellement plus rapide que ``inlist`` car aucune conversion de chaîne ou construction de liste n'est effectuée.

en: 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.
fr: 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.

en: Examples:
fr: Exemples :

en: ``program: field('series') == 'foo'`` returns ``'1'`` if the book's series is `foo`, otherwise ``''``.
fr: ``program:field('series') == 'foo'`` retourne ``'1'`` si la série du livre est `foo`, sinon ``''``.

en: ``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 ``''``.
fr: ``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 ``''``.

en: ``program: 'science' inlist $#genre`` returns ``'1'`` if any of the values retrieved from the book's genres match the regular expression ``science``, e.g., `Science`, `History of Science`, `Science Fiction` etc., otherwise ``''``.
fr: ``program: 'science' inlist $#genre`` retourne ``'1'`` si l'une des valeurs du genres du livre correspond à l'expression régulière ``science``, par exemple, `Science`, `Histoire de la science`, `Science Fiction` etc., sinon ``''``.

en: ``program: '^science$' inlist $#genre`` returns ``'1'`` if any of the book's genres exactly match the regular expression ``^science$``, e.g., `Science`, otherwise ``''``. The genres `History of Science` and `Science Fiction` don't match.
fr: ``program: '^science$' inlist $#genre` retourne `'1'`` si l'un des genres du livre correspond exactement à l'expression régulière ``^science$``, par exemple, `Science`, sinon ``''``. Les genres `Histoire des sciences` et `Science Fiction` ne correspondent pas.

en: ``program: 'asimov' inlist $authors`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
fr: ``program: 'asimov' inlist $authors`` retourne ``'1'`` si un auteur correspond à l'expression régulière ``asimov``, ex., `Asimov, Isaac` ou `Isaac Asimov`, sinon ``''``.

en: ``program: 'asimov' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
fr: ``program: 'asimov' inlist_field 'authors'`` retourne ``'1'`` si un auteur correspond à l'expression régulière ``asimov``, ex., `Asimov, Isaac` ou `Isaac Asimov`, sinon ``''``.

en: ``program: 'asimov$' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov$``, e.g., `Isaac Asimov`, otherwise ``''``. It doesn't match `Asimov, Isaac` because of the ``$`` anchor in the regular expression.
fr: ``program: 'asimov$' inlist_field 'authors'`` retourne ``'1'`` si un auteur correspond à l'expression régulière ``asimov$``, ex., `Isaac Asimov`, sinon ``''``. Il ne correspond pas a `Asimov, Isaac` a cause de l'ancre ``$`` dans l'expression régulière.

en: ``program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` returns ``'bar'`` if the book's series is not `foo`. Otherwise it returns ``'mumble'``.
fr: ``program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` retourne ``'bar'`` si la série du livre n'est pas `foo`. Sinon, retourne ``'mumble'``.

en: ``program: if field('series') == 'foo' || field('series') == '1632' then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
fr: ``program: if field('series') == 'foo' || field('series') == '1632' then 'yes' else 'no' fi`` retourne ``'yes'`` si séries existe soit `foo` soit `1632`, sinon ``'no'``.

en: ``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
fr: ``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi`` retourne ``'yes'`` si la série existe soit `foo` ou `1632`, sinon ``'no'``.

en: ``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the ``>`` operator does a lexical comparison.
fr: ``program: if '11' > '2' then 'yes' else 'no' fi`` `renvoie ``'no'`` parce que l'opérateur ``>`` fait une comparaison lexicale.

en: ``program: if 11 ># 2 then 'yes' else 'no' fi`` returns ``'yes'`` because the ``>#`` operator does a numeric comparison.
fr: ``Program: if 11 ># 2 then 'yes' else 'no' fi`` renvoie ``'yes'`` parce que l'opérateur ``>#`` effectue une comparaison numérique.

en: **Functions in General Program Mode**
fr: **Fonction en Mode Programme Général**

en: See :ref:`template_functions_reference` for the list of functions built into the template language.
fr: Voir :ref:`template_functions_reference` pour la liste des fonctions intégrées au langage des modèles.

en: As opposed to :ref:`Single Function Mode <single_mode>`, in General Program Mode you must specify the first parameter ``value``.
fr: Contrairement à :ref:`Single Function Mode <single_mode>`, en Mode Programme Général, vous devez spécifier le premier paramètre ``value``.

en: All parameters are expression_lists (see the grammar above).
fr: Tous les paramètres sont des listes d'expressions (voir la grammaire ci-dessus).

en: More complex programs in template expressions - Template Program Mode
fr: Programmes plus complexes dans les expressions modèles - Mode Programme de Modèles

en: `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.
fr: 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.

en: 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::
fr: 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 ::

en: The example shows several things:
fr: L'exemple montre plusieurs choses :

en: `TPM` is used if the expression begins with ``:'`` and ends with ``'}``. Anything else is assumed to be in :ref:`Single Function Mode <single_mode>`.
fr: `MPP` est utilisé si l'expression commence par ``:'`` et se termine par ``'}``. Tout le reste est supposé être en :ref:`Mode Fonction Unique <single_mode>`.

en: If the template contains a prefix and suffix, the expression ends with ``'|`` where the ``|`` is the delimiter for the prefix. Example::
fr: Si le modèle contient un préfixe et un suffixe, l'expression se termine par ``'|`` où le ``|`` est le délimiteur du préfixe. Exemple ::

en: Functions must be given all their arguments. For example, the standard built-in functions must be given the initial parameter ``value``.
fr: Les fonctions doivent être données avec tous leurs arguments. Par exemple, les fonctions intégrées standard doivent recevoir le paramètre initial ``value``.

en: The variable ``$`` is usable as the ``value`` argument and stands for the value of the field named in the template, ``series`` in this case.
fr: La variable ``$`` est utilisable comme argument ``value`` et représente la valeur du champ nommé dans le modèle, ``#series`` dans ce cas.

en: white space is ignored and can be used anywhere within the expression.
fr: les espaces sont ignorés et peuvent être utlisés n'importe où dans l'expression.

en: constant strings are enclosed in matching quotes, either ``'`` or ``"``.
fr: les chaînes constantes sont entre guillemets, soit ``'`` ou ``"``.

en: 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 `]]`. Advice: if your program contains ``{`` and ``}`` characters then you should use `General Program Mode`.
fr: 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 `]]`. Conseil : si votre programme contient des caractères ``{`` et ``}``, vous devriez utiliser le `Mode Programme Général`.

en: Python Template Mode
fr: Mode Programmation Python

en: 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.
fr: Mode Programmation Python (MPP) vous permet d'écrire des modèles en utilisant le langage Python natif et `l'API de calibre <https://manual.calibre-ebook.com/develop.html#api-documentation-for-various-parts-of-calibre>`_. L'API de la base de données sera la plus utile ; une discussion plus approfondie dépasse le cadre de ce manuel. Les modèles MPP sont plus rapides et peuvent faire des opérations plus compliquées, mais vous devez savoir comment écrire du code en Python en utilisant l'API calibre.

en: A PTM template begins with:
fr: Un modèle de MPP commence par :

en: 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.
fr: Vous pouvez ajouter le texte ci-dessus à votre modèle en utilisant le menu contextuel, généralement accessible par un clic droit. Les commentaires ne sont pas significatifs et peuvent être supprimés. Vous devez utiliser l'indentation python.

en: 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.
fr: L'objet context prend en charge ``str(context)`` qui retourne une chaîne de caractères du contenu du contexte, et ``context.attributes`` qui retourne une liste des noms d'attributs dans le contexte.

en: 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:
fr: L'attribut ``context.funcs`` permet d'appeler les fonctions modèles intégrés et utilisateurs, ainsi que les modèles stockés MPG/Python, afin que vous puissiez les exécuter directement dans votre code. Les fonctions sont récupérées à l'aide de leur nom. Si le nom entre en conflit avec un mot clé Python, ajoutez un trait de underscore à la fin du nom. Exemples :

en: 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.
fr: Voici un exemple de modèle MPP qui produit une liste de tous les auteurs d'une série. La liste est stockée dans une `Colonne construite à partir d'autres colonnes, se comporte comme des étiquettes`. Elle est affichée dans :guilabel:`Détails du livre` et l'option :guilabel:`sur des lignes séparées` est cochée (dans :guilabel:`Préférences->Apparence et présentation->Détails du livre`). Cette option exige que la liste soit séparée par des virgules. Pour satisfaire à cette exigence, le modèle convertit les virgules dans les noms d'auteurs en points-virgules puis construit une liste d'auteurs séparés par des virgules. Les auteurs sont ensuite triés, c'est pourquoi le modèle utilise author_sort.

en: The output in :guilabel:`Book details` looks like this:
fr: La sortie dans :guilabel:`Détails du livre` ressemble à ceci :

en: E-book conversion dialog
fr: Dialogue de conversion des livres numériques

en: Templates and URLs
fr: Modèles et URLs

en: You can use templates to construct URLs. Two cases are described here:
fr: Vous pouvez utiliser des modèles pour construire des URL. Deux cas sont décrits ici :

en: Custom column :guilabel:`Book details` search URLs
fr: Colonne personnalisée :guilabel:`Détails du livre` URL de recherche

en: The calibre URL scheme
fr: Le système d'URL de calibre

en: **Custom column book details search URLs**
fr: **Colonne personnalisée Détails du livre` URL de recherche**

en: When you create a custom column you can provide a URL to be used in :guilabel:`Book details` using a template. For example, if you have a custom column for `Translators` you can define a URL to take you to a site for translators. Book details search URLs can be provided for `Text`, `Enumerated`, `Series`, and `Column built from other column` column types.
fr: Lorsque vous créez une colonne personnalisée, vous pouvez fournir une URL à utiliser dans :guilabel:`Détails du livre` à l'aide d'un modèle. Par exemple, si vous avez une colonne personnalisée pour `Traducteurs`, vous pouvez définir une URL qui vous conduira à un site pour les traducteurs. Des URLs de recherche de détails de livres peuvent être fournies pour les types de colonnes `Texte`, `Énumération`, `Séries`, et `Colonne construite à partir d'autres colonnes`.

en: When an item with a `search template` is clicked in :guilabel:`Book details` the template is evaluated. It is provided the normal book metadata. It is also provided three additional fields:
fr: Lorsqu'un élément avec un `modèle de recherche` est cliqué dans :guilabel:`Détails du livre`, le modèle est évalué. Il reçoit les métadonnées normales du livre. Trois champs supplémentaires lui sont également fournis :

en: ``item_value``: the value of the clicked item.
fr: ``item_value`` : la valeur de l'élément cliqué.

en: ``item_value_quoted``: the value of clicked item, URL-encoded. Special characters are escaped to make them valid in URLs and spaces are replaced by ``'+'`` (plus) signs.
fr: ``item_value_quoted`` : la valeur de l'élément cliqué, encodée en URL. Les caractères spéciaux sont échappés pour les rendre valides dans les URL et les espaces sont remplacés par des signes ``'+'`` (plus).

en: ``item_value_no_plus``: the value of clicked item, URL-encoded. Special characters are escaped to make them valid in URLs and spaces are replaced by the ``%20``, not plus.
fr: ``item_value_quoted`` : la valeur de l'élément cliqué, encodée en URL. Les caractères spéciaux sont échappés pour les rendre valides dans les URL et les espaces sont remplacés par ``%20``.

en: There are several ways to construct the URL. The following use Wikipedia as an example.
fr: Il existe plusieurs façons de construire l'URL. L'exemple suivant est celui de Wikipédia.

en: The simplest is a basic template::
fr: Le plus simple est un modèle de base ::

en: In some cases you might want to do more processing. There are four template functions you can use, depending on the complexity of the processing.
fr: Dans certains cas, vous pouvez souhaiter effectuer un traitement plus poussé. Il existe quatre fonctions de modèle que vous pouvez utiliser, en fonction de la complexité du traitement.

en: For example, assume you have a custom column `Translators` (``#translators``) where the names are `Last name, First name`. You might need to convert the name to `First name Last name` when creating the URL. You can use the :ref:`ff_make_url` function to do this::
fr: Par exemple, supposons que vous ayez une colonne personnalisée `Traducteurs` (`#translators`) dont les noms sont `Nom, Prénom`. Vous pourriez avoir besoin de convertir le nom en `Prénom Nom` lors de la création de l'URL. Vous pouvez utiliser la fonction :ref:`ff_make_url` pour ce faire ::

en: If we assume that the translator's name is `Boy-Żeleński, Tadeusz` then the above template produces the link::
fr: Si nous supposons que le nom du traducteur est `Boy-Żeleński, Tadeusz`, le modèle ci-dessus produit le lien ::

en: Note that the person's first name is now first, the space is now a plus, and that the non-English characters in the last name are URL-encoded.
fr: Notez que le prénom de la personne est maintenant en premier, que l'espace est maintenant un plus et que les caractères non anglais du nom de famille sont encodés pour l'URL.

en: The functions :ref:`ff_make_url_extended`, :ref:`ff_query_string`, and :ref:`ff_encode_for_url` might be useful depending upon any additional processing complexity.
fr: Les fonctions :ref:`ff_make_url_extended`, :ref:`ff_query_string`, et :ref:`ff_encode_for_url` peuvent être utiles en fonction de la complexité du traitement.

en: **The calibre URL scheme**
fr: **Le système d'URL de calibre**

en: Calibre supports several different URLs to navigate your calibre libraries. This section shows how to use templates to construct some of the URLs. See :doc:`url_scheme` for details on the URLs available.
fr: Calibre prend en charge plusieurs URL différentes pour naviguer dans vos bibliothèques Calibre. Cette section montre comment utiliser des modèles pour construire certaines de ces URLs. Voir :doc:`url_scheme` pour plus de détails sur les URLs disponibles.

en: Switch to a specific library. The syntax of this URL is::
fr: Basculer à une bibliothèque spécifique. La syntaxe de cette URL est la suivante ::

en: ``Library_Name`` must be replaced with the name of the calibre library you wish to open. The library name is shown in the title bar of the window. It is a simple name, not the file path to the library. You must spell it as shown in the title bar, including letter case. The character ``_`` (underscore) stands for the current library. If the name contains any spaces or special characters then it must be hex encoded using the :ref:`ff_to_hex` function, as in the following example::
fr: ``Library_Name`` doit être remplacé par le nom de la bibliothèque Calibre que vous souhaitez ouvrir. Le nom de la bibliothèque est affiché dans la barre de titre de la fenêtre. Il s'agit d'un nom simple, et non du chemin d'accès à la bibliothèque. Vous devez l'épeler comme indiqué dans la barre de titre, en respectant les majuscules et les minuscules. Le caractère ``_`` (trait de soulignement) représente la bibliothèque courante. Si le nom contient des espaces ou des caractères spéciaux, il doit être codé en hexadécimal à l'aide de la fonction :ref:`ff_to_hex`, comme dans l'exemple suivant ::

en: The template generates the URL::
fr: Le modèle génère l'URL ::

en: You can replace the ``current_library_name()`` function with the actual name of the library, as in::
fr: Vous pouvez remplacer la fonction ``current_library_name()`` par le nom réel de la bibliothèque, comme dans ::

en: Links to show books. These links select a book in the calibre library. The syntax for this URL is::
fr: Liens pour afficher les livres. Ces liens permettent de sélectionner un livre dans la bibliothèque Calibre. La syntaxe de cette URL est ::

en: The ``book id`` is the numeric calibre id for the book, available to templates as ``$id``. As above, the library name might need to be hex encoded. Here is an example::
fr: Le ``book id`` est l'identifiant numérique du livre, disponible pour les modèles sous la forme ``$id``. Comme ci-dessus, le nom de la bibliothèque peut avoir besoin d'être encodé en hexadécimal. Voici un exemple ::

en: It produces the URL::
fr: Il produit l'URL ::

en: Searching for books. These links search for books in the specified calibre library. The syntax for this URL is::
fr: Chercher de livres. Ces liens permettent de rechercher des livres dans la bibliothèque Calibre spécifiée. La syntaxe de cette URL est ::

en: where `query` is any valid calibre search expression. You must hex encode any query containing spaces or special characters, which generally means all of them. For example, the calibre search expression for searching for a hierarchical tag beginning with 'AA' is ``tags:"=.AA"``. This template constructs a search URL for that expression::
fr: où `query` est une expression de recherche Calibre valide. Vous devez coder en hexadécimal toute requête contenant des espaces ou des caractères spéciaux, c'est-à-dire généralement tous. Par exemple, l'expression de recherche calibre pour rechercher une balise hiérarchique commençant par 'AA' est ``tags:"=.AA"``. Ce modèle construit une URL de recherche pour cette expression ::

en: The resulting URL is::
fr: L'URL obtenue est ::

en: Here is an example of the same URL built using the :ref:``ff_make_url_extended`` function instead of :ref:`ff_strcat`::
fr: Voici un exemple de la même URL construite en utilisant la fonction :ref:``ff_make_url_extended`` au lieu de :ref:`ff_strcat` ::

en: Open a book details window on a book in some library. The syntax for this URL is::
fr: Ouvrir une fenêtre de détails du livre pour un livre dans une bibliothèque. La syntaxe de cette URL est ::

en: An example template is::
fr: Un exemple de modèle est ::

en: which produces the URL::
fr: qui produit l'URL ::

en: Open the notes associated with an author/series/etc. The syntax of the URL is::
fr: Ouvrir les notes associées à un auteur/une série/etc. La syntaxe de cette URL est ::

en: ``Field_Name`` is the lookup name of the field. If the field is a custom column then replace the ``#`` character with an underscore (``_``). ``Item_Id`` is the internal numeric ID of the value in the field. There isn't a template function that returns the ``Item_Id``, so templates will normally use the second form, ``Hex_Encoded_Item_Name``. Here is a sample template that opens the note for the person ``Boy-Żeleński, Tadeusz`` in the field ``#authtest``::
fr: ``Field_Name`` est le nom du champ. Si le champ est une colonne personnalisée, remplacez le caractère ``#`` par un trait de soulignement (``_``). ``Item_Id`` est l'identifiant numérique interne de la valeur du champ. Il n'y a pas de fonction de template qui retourne l'``Item_Id``, donc les templates utiliseront normalement la seconde forme, ``Hex_Encoded_Item_Name``. Voici un exemple de modèle qui ouvre la note pour la personne ``Boy-Żeleński, Tadeusz`` dans le champ `#authtest` ::

en: Stored templates
fr: Modèles stockés

en: 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``:
fr: Les modes :ref:`Mode Général de Programmation` et :ref:`Mode Programmation Python` permettent d'enregistrer des modèles et d'appeler ces modèles à partir d'un autre modèle, de la même manière que l'on appelle des fonctions stockées. Vous enregistrez les modèles en utilisant :guilabel:`Préférences->Avancées->Modèles de fonctions`. Plus d'informations sont fournies dans cette boîte de dialogue. Vous appelez un modèle de la même manière que vous appelez une fonction, en passant des arguments positionnels si vous le souhaitez. Un argument peut être n'importe quelle expression. Exemples d'appel d'un modèle, en supposant que le modèle stocké est nommé ``foo``

en: ``foo()`` -- call the template passing no arguments.
fr: ``foo()`` -- appelle le modèle en ne passant aucun argument.

en: ``foo(a, b)`` call the template passing the values of the two variables ``a`` and ``b``.
fr: ``foo(a, b)`` appelle le modèle en passant les valeurs des deux variables ``a`` et ``b``.

en: ``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``.
fr: ``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``.

en: 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``::
fr: En MGP, vous récupérez les arguments passés dans l'appel au modèle stocké en utilisant la fonction ``arguments``. Cette fonction déclare et initialise des variables locales, en fait des paramètres. Les variables sont positionnelles ; elles obtiennent la valeur du paramètre donné dans l'appel à la même position. Si le paramètre correspondant n'est pas fourni dans l'appel, alors ``arguments`` attribue à cette variable la valeur par défaut fournie. S'il n'y a pas de valeur par défaut, la variable prend la valeur de la chaîne vide. Par exemple, la fonction ``arguments`` suivante déclare 2 variables, ``key``, ``alternate`` ::

en: Examples, again assuming the stored template is named ``foo``:
fr: Par exemple, en supposant encore une fois que le modèle stocké est nommé ``foo`` :

en: ``foo('#myseries')`` -- argument ``key`` is assigned the value ``'myseries'`` and the argument ``alternate`` is assigned the default value ``'series'``.
fr: ``foo('#myseries')`` -- l'argument ``key`` se voit attribuer la valeur ``myseries'`` et l'argument ``alternate`` se voit attribuer la valeur par défaut ``'series'``.

en: ``foo('series', '#genre')`` the variable ``key`` is assigned the value ``'series'`` and the variable ``alternate`` is assigned the value ``'#genre'``.
fr: ``foo('series', '#genre')`` la variable ``key`` prend la valeur ``'series'`` et la variable ``alternate`` prend la valeur ``'#genre'``.

en: ``foo()`` -- the variable ``key`` is assigned the empty string and the variable ``alternate`` is assigned the value ``'series'``.
fr: ``foo()`` -- la variable ``key`` se voit attribuer la chaîne vide et la variable ``alternate`` se voit attribuer la valeur ``'series'``.

en: 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.
fr: En MPP, les arguments sont passés dans le paramètre ``arguments``, qui est une liste de chaînes de caractères. Il n'y a aucun moyen de spécifier des valeurs par défaut. Vous devez vérifier la longueur de la liste ``arguments`` pour être sûr que le nombre d'arguments est celui que vous attendez.

en: 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.
fr: 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é.

en: Providing additional information to templates
fr: Fournir des informations supplémentaires aux modèles

en: 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.
fr: 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.

en: **Developer: how to pass additional information**
fr: **Développeur : comment transmettre des informations supplémentaires**

en: 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.
fr: L'information supplémentaire est un dictionnaire Python contenant des paires ``nom_variable : valeur_variable`` où les valeurs doivent être des chaînes. Le modèle peut accéder au dictionnaire, en créant des variables locales nommées ``nom_de_variable`` contenant la valeur ``variable_valeur``. L'utilisateur ne peut pas changer le nom, il est donc préférable d'utiliser des noms qui n'entreront pas en collision avec d'autres variables locales du modèle, par exemple en préfixant le nom par un trait de soulignement.

en: This dictionary is passed to the template processor (the ``formatter``) using the named parameter ``global_vars=your_dict``. The full method signature is::
fr: Ce dictionnaire est passé au processeur de modèle (le ``formatter``) en utilisant le paramètre nommé ``global_vars=votre_dict``. La signature complète de la méthode est ::

en: **Template writer: how to access the additional information**
fr: **Rédacteur de modèles : comment accéder aux informations complémentaires**

en: You access the additional information (the ``globals`` dictionary) in a template using the template function::
fr: Vous accédez aux informations supplémentaires (le dictionnaire ``globals``) dans un modèle en utilisant la fonction de modèle ::

en: 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.
fr: 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.

en: A template can set a value in the ``globals`` dictionary using the template function::
fr: Un modèle peut définir une valeur dans le dictionnaire ``globals`` en utilisant la fonction de modèle ::

en: 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``.
fr: Cette fonction définit la paire clé:valeur du dictionnaire ``globals`` ``id:value`` où ``value`` est la valeur de la variable locale du modèle ``id``. Si cette variable locale n'existe pas, alors ``valeur`` est fixée au résultat de l'évaluation de ``expression``.

en: Notes on the difference between modes
fr: Notes sur la différence entre les modes

en: 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.
fr: 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.

en: Differences:
fr: Différences :

en: In SFM the value of the column is always passed as an 'invisible' first argument to a function included in the template.
fr: Dans MFS, la valeur de la colonne est toujours passée comme premier argument 'invisible' à une fonction incluse dans le modèle.

en: SFM doesn't support the difference between variables and strings; all values are strings.
fr: 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.

en: The following SFM template returns either the series name or the string "no series"::
fr: Le modèle SFM suivant renvoie soit le nom de la série, soit la chaîne "pas de série" ::

en: The equivalent template in `TPM` is ::
fr: Le modèle équivalent dans `MPM` est ::

en: The equivalent template in `GPM` is::
fr: Le modèle équivalent dans `MGP` est ::

en: 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).
fr: 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).

en: 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.
fr: 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.

en: 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::
fr: 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 ::

en: `TPM` and `GPM` support nested functions. The above template in `TPM` would be::
fr: `MPM` et `MPG` soutiennent des fonctions imbriquées. Le modèle ci-dessus dans `MPM` serait ::

en: In `GPM` it would be::
fr: Dans `MPG`, ce serait ::

en: 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`.
fr: 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`.

en: User-defined Python template functions
fr: Fonctions des modèles Python définis par l'utilisateur

en: 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. Note that you can use `Python Templates` for a similar purpose. As calling user-defined functions is faster than calling a Python template, user-defined functions might be more efficient depending on the complexity of what the function or template does.
fr: 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. Notez que vous pouvez utiliser les `Modèles Python` dans un but similaire. Comme l'appel à des fonctions définies par l'utilisateur est plus rapide que l'appel à un modèle Python, les fonctions définies par l'utilisateur peuvent être plus efficaces en fonction de la complexité de ce que fait la fonction ou le modèle.

en: Special notes for using templates in different contexts
fr: Remarque particulières pour l'utilisation des modèles dans différents contextes

en: In the GUI (:guilabel:`Columns made from other columns` and :guilabel:`Template searches`):
fr: Dans l'interface graphique (:guilabel:`Colonnes créées à partir d'autres colonnes` et :guilabel:`Recherches de modèles`) :

en: GPM templates work as before.
fr: Les modèles GPM fonctionnent comme auparavant.

en: Python templates have full access to the calibre database.
fr: Les modèles Python ont un accès complet à la base de données Calibre.

en: In icon rules:
fr: Dans les définition d'icônes :

en: icon rule templates have no book data so field-based functions such as :ref:`ff_format_date_field`, :ref:`ff_list_count_field`, and :ref:`ff_check_yes_no` won't work.
fr: Les modèles de règles d'icônes n'ont pas de données de livre, donc les fonctions basées sur les champs telles que :ref:`ff_format_date_field`, :ref:`ff_list_count_field`, et :ref:`ff_check_yes_no` ne fonctionneront pas.

en: In the Content server:
fr: Dans le serveur de contenu :

en: Templates have access to the new API but not the old API (LibraryDatabase).
fr: Les modèles ont accès à la nouvelle API mais pas à l'ancienne (LibraryDatabase).

en: Because of the above, the following formatter functions are not guaranteed to work in GPM templates (composite columns, icon rules, etc) and should be avoided if you use the content server:
fr: En raison de ce qui précède, le fonctionnement des fonctions de formatage suivantes n'est pas garanti dans les modèles GPM (colonnes composées, règles d'icône, etc.) et devrait être évité si vous utilisez le serveur de contenu :

en: Special notes for save/send templates
fr: Notes spéciales pour la sauvergarde/l'envoi des modèles

en: Special processing is applied when a template is used in a :guilabel:`Save to disk` or :guilabel:`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.
fr: Un traitement spécial est appliqué lorsqu'un modèle est utilisé dans un modèle :guilabel:`Enregistrer sur le disque` ou :guilabel:`Envoyer vers le périphérique`. Les valeurs des champs sont nettoyées, en remplaçant les caractères spéciaux des systèmes de fichiers par des traits de soulignement, y compris les barres obliques. Cela signifie que le texte des champs ne peut pas être utilisé pour créer des dossiers. Toutefois, les barres obliques ne sont pas modifiées dans les chaînes de préfixes ou de suffixes, de sorte que les barres obliques dans ces chaînes entraîneront la création de dossiers. Il est donc possible de créer une structure de dossiers à profondeur variable.

en: 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::
fr: 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 :

en: The slash and the hyphen appear only if series is not empty.
fr: La barre oblique et le trait d'union apparaissent uniquement si la série n'est pas vide.

en: 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.
fr: 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.

en: To accomplish this, we:
fr: Pour accomplir cela, nous :

en: 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`.
fr: 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`.

en: 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`.
fr: 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`.

en: 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.
fr: 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.

en: Tips
fr: Astuces

en: 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.
fr: 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.

en: Templates can use other templates by referencing composite columns built with the desired template. Alternatively, you can use Stored Templates.
fr: 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.

en: 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.
fr: 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.

en: The technique described above to show numbers even if they have a zero value works with the standard field series_index.
fr: 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.

en: Template function reference
fr: Référence des modèles de fonctions
