calibre - en to ru translation catalogue (256 entries)

en: The calibre template language
ru: Язык шаблонов 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:
ru: Язык шаблонов calibre — это специфичный для calibre язык, используемый в calibre для таких задач, как указание путей к файлам, форматирование значений и вычисление значений для столбцов, указанных пользователем. Примеры:

en: Specify the folder structure and file names when saving files from the calibre library to the disk or e-book reader.
ru: Укажите структуру папок и имена файлов при сохранении файлов из библиотеки calibre на диск или в читалку электронных книг

en: Define rules for adding icons and colors to the calibre book list.
ru: Определите правила добавления значков и цветов в список книг calibre.

en: Define `virtual columns` that contain data from other columns.
ru: Определите виртуальные столбцы, содержащие данные из других столбцов.

en: Advanced library searching.
ru: Расширенный поиск в библиотеке.

en: Advanced metadata search and replace.
ru: Расширенный поиск и замена метаданных.

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.
ru: Язык построен на понятии «шаблон», который определяет, какие метаданные книги использовать, вычисления над этими метаданными и способ их форматирования.

en: Basic templates
ru: Базовые шаблоны

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``::
ru: Базовый шаблон состоит из одного или нескольких ``шаблонных выражений``. ``Шаблонное выражение`` состоит из текста и имен в фигурных скобках (``{}``), которые заменяются соответствующими метаданными из обрабатываемой книги. Например, шаблон по умолчанию в calibre, используемый для сохранения книг на устройство, имеет 4 ``шаблонных выражения``::

en: For the book "The Foundation" by "Isaac Asimov" the  will become::
ru: Для книги Айзека Азимова «Основание» "The Foundation" by "Isaac Asimov" им станет:

en: then for "The Foundation" the template produces::
ru: затем для книги «Основание» шаблон создает::

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``.
ru: ``Шаблонное выражение`` может получить доступ ко всем метаданным, доступным в calibre, включая настраиваемые столбцы (столбцы, которые вы создаете самостоятельно), используя ``имя поиска`` столбца. Чтобы найти поисковое имя для столбца (иногда называемых полями), наведите указатель мыши на заголовок столбца в списке книг calibre. Имена подстановки для настраиваемых столбцов всегда начинаются с символа ``#``. Для столбцов типа серии есть дополнительное поле с именем ``#lookup name_index``, которое является индексом серии для этой книги в серии. Например, если у вас есть столбец настраиваемой серии с именем ``#myseries``, также будет столбец с именем ``#myseries_index``. Индекс столбца стандартной серии называется ``series_index``.

en: In addition to the standard column based fields, you also can use:
ru: В дополнение к стандартным полям на основе столбцов вы также можете использовать:

en: ``{formats}`` - A list of formats available in the calibre library for a book
ru: ``{formats}``- Список форматов, доступных в библиотеке calibre для книги

en: ``{identifiers:select(isbn)}`` - The ISBN of the book
ru: ``{identifiers:select(isbn)}`` - ISBN книги

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::
ru: Если метаданные для поля для данной книги не определены, тогда поле в шаблоне заменяется пустой строкой (``''``). Например, рассмотрим следующий шаблон::

en: If Asimov's book "Second Foundation" is in the series "Foundation" then the template produces::
ru: Если книга Азимова «Второе основание» входит в серию «Основание», то шаблон дает::

en: If a series has not been entered for the book then the template produces::
ru: Если для книги не введена серия, то шаблон выдает::

en: The template processor automatically removes multiple slashes and leading or trailing spaces.
ru: Обработчик шаблонов автоматически удаляет несколько косых черт и начальные или конечные пробелы.

en: Advanced formatting
ru: Расширенное форматирование

en: In addition to metadata substitution, templates can conditionally include additional text and control how substituted data is formatted.
ru: Помимо подстановки метаданных, шаблоны могут условно включать дополнительный текст и управлять форматированием заменяемых данных.

en: **Conditionally including text**
ru: **Условно включая текст**

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.
ru: Иногда вы хотите, чтобы текст отображался в выводе, только если поле не пустое. Обычный случай - это series и series_index, когда вы не хотите ничего или два значения, разделенные дефисом. calibre обрабатывает этот случай, используя специальный синтаксис ``шаблонного выражения``.

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:
ru: Например, используя приведенный выше пример Foundation, предположим, что вы хотите, чтобы шаблон создавал `Foundation - 3 - Second Foundation`. Этот шаблон производит такой вывод:

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:
ru: Однако, если в книге нет серии, шаблон создаст `- - title`, что, вероятно, не то, что вам нужно. Обычно люди хотят, чтобы в результате получился заголовок без лишних дефисов. Вы можете сделать это, используя следующий синтаксис шаблона:

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.
ru: Это ``шаблонное выражение`` говорит, что если ``field`` имеет значение ``XXXX``, то результатом будет ``prefix_textXXXXXsuffix_text``. Если поле пусто (не имеет значения), результатом будет пустая строка (ничего), потому что префикс и суффикс игнорируются. Префикс и суффикс могут содержать пробелы.

en: **Do not use subtemplates (`{ ... }`) or functions (see below) in the prefix or the suffix.**
ru: **Не используйте подшаблоны (`{ ... }`) или функции (см. Ниже) в префиксе или суффиксе.**

en: Using this syntax, we can solve the above no-series problem with the template::
ru: Используя этот синтаксис, мы можем решить указанную выше проблему без серии с шаблоном::

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`.
ru: Дефисы будут добавлены только в том случае, если у книги есть индекс серии, который есть только в том случае, если в ней есть серия. Продолжая пример с Foundation снова, шаблон создаст `Foundation - 1 - Second Foundation`.

en: Notes:
ru: Примечания:

en: You must include the colon after the ``lookup name`` if you are using a prefix or a suffix.
ru: Вы должны включить двоеточие после ``имени поиска``, если используете префикс или суффикс.

en: You must either use either no or both ``|`` characters. Using one, as in ``{field:| - }``, is not allowed.
ru: Вы должны использовать либо никакой, либо оба символа ``|``. Использовать один, как в ``{field:| -}``, не допускается.

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}``.
ru: Допускается отсутствие текста для префикса или суффикса, например, в ``{series:|| -}``. Шаблон ``{title:||}`` такой же, как ``{title}``.

en: **Formatting**
ru: **Форматирование**

en: Suppose you want the ``series_index`` to be formatted as three digits with leading zeros. This does the trick:
ru: Предположим, вы хотите, чтобы ``series_index`` был отформатирован как три цифры с ведущими нулями. Это помогает:

en: ``{series_index:0>3s}`` - Three digits with leading zeros
ru: ``{series_index: 0>3s}`` - три цифры с ведущими нулями

en: For trailing zeros, use:
ru: Для завершающих нулей используйте:

en: ``{series_index:0<3s}`` - Three digits with trailing zeros
ru: ``{series_index: 0<3s}``- три цифры с завершающими нулями

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:
ru: Если вы используете индексы серий с дробными значениями, например 1.1, и нужно чтобы десятичные точки совпадали. Например, чтобы индексы 1 и 2.5 отображались как 01.00 и 02.50 и правильно сортировались на устройстве, которое выполняет лексическую сортировку. Для этого используйте:

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.
ru: ``{series_index: 05.2f}`` - пять символов, состоящих из двух цифр с ведущими нулями, десятичной точкой и двумя цифрами после десятичной точки.

en: If you want only the first two letters of the data, use:
ru: Если вам нужны только первые две буквы данных, используйте:

en: ``{author_sort:.2}`` - Only the first two letters of the author sort name
ru: ``{author_sort:.2}`` - Только первые две буквы сортировочного имени автора

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>`_.
ru: Большая часть форматирования языка шаблонов calibre из Python. Дополнительные сведения о синтаксисе расширенных операций форматирования см. в `Python documentation <https://docs.python.org/3/library/string.html#formatstrings>`_.

en: Using templates to define custom columns
ru: Использование шаблонов для определения пользовательских столбцов

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}``.
ru: Шаблоны могут использоваться для отображения информации, которая не входит в метаданные calibre, или для отображения метаданных, отличных от обычного формата calibre. Например, чтобы отобразить ``ISBN``, поле, которое штатно не отображается в calibre. Создайте настраиваемый столбец с типом `Столбец, построенный из других столбцов` (в дальнейшем называемый `составные столбцы`) и предоставьте шаблон для генерации отображаемого текста. В столбце отобразится результат оценки шаблона. Чтобы отобразить ISBN, создайте составной столбец и введите ``{identifiers:select (isbn)}`` в поле шаблона. Чтобы отобразить столбец, содержащий значения двух пользовательских столбцов серий, разделённых запятой, используйте ``{#series1:||,}{#series2}``.

en: Composite columns can use any template option, including formatting.
ru: В составных столбцах можно использовать любой параметр шаблона, включая форматирование.

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.
ru: Примечание. Вы не можете редактировать данные, отображаемые в составном столбце. Вместо этого вы редактируете исходные столбцы. Если вы редактируете составной столбец, например, дважды щелкнув по нему, calibre откроет для редактирования шаблон, а не базовые данные.

en: Templates and plugboards
ru: Шаблоны и коммутации

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.
ru: Коммутационные панели используются для изменения метаданных, записанных в книги, во время операций отправки на устройство и сохранения на диск. Коммутационная панель позволяет указать шаблон предоставления данных для записи в метаданные книги. Вы можете использовать коммутационные панели для изменения следующих полей: authors, author_sort, language, publisher, tags, title, title_sort. Эта функция помогает в использовании разных метаданных в книгах на устройствах, решении проблем сортировки или отображения.

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.
ru: При создании коммутационной панели вы указываете формат и устройство, для которых она будет использоваться. Предоставляется специальное устройство ``save_to_disk``, которое используется при сохранении форматов (в отличие от их отправки на устройство). После того, как вы выбрали формат и устройство, вы выбираете поля метаданных, которые нужно изменить, предоставляя шаблоны для предоставления новых значений. Эти шаблоны `присоединены` к своим полям назначения, отсюда и название `plugboards`. Конечно, в этих шаблонах можно использовать составные столбцы.

en: Plugboards are quite flexible and can be written in Single Function Mode, Template Program Mode, General Program Mode, or Python Template mode.
ru: Плагборды довольно гибкие и могут быть написаны в режиме Single Function Mode, Template Program Mode, General Program Mode, или Python Template mode.

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:
ru: Когда может применяться коммутационная панель (контент-сервер, сохранение на диск или отправка на устройство), calibre выполняет поиск определенных подключаемых модулей, чтобы выбрать правильный вариант для данного формата и устройства. Например, чтобы найти подходящую коммутационную панель для книги EPUB, отправляемой на устройство ANDROID, calibre выполняет поиск в коммутационных панелях, используя следующий порядок поиска:

en: a plugboard with an exact match on format and device, e.g., ``EPUB`` and ``ANDROID``
ru: коммутационная панель с точным соответствием по формату и устройству, например, ``EPUB`` и ``ANDROID``

en: a plugboard with an exact match on format and the special ``any device`` choice, e.g., ``EPUB`` and ``any device``
ru: коммутационная панель с точным соответствием по формату и специальным выбором ``any device``, например, ``EPUB`` и ``any device``

en: a plugboard with the special ``any format`` choice and an exact match on device, e.g., ``any format`` and ``ANDROID``
ru: коммутационная панель со специальным выбором ``any format`` и точным соответствием на устройстве, например, ``any format`` и ``ANDROID``

en: a plugboard with ``any format`` and ``any device``
ru: коммутационная панель с ``any format`` и ``any device``

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.
ru: Поля тегов и авторов обрабатываются по-особому, потому что оба эти поля могут содержать более одного элемента. У книги может быть много тегов и много авторов. Когда вы указываете, что одно из этих двух полей должно быть изменено, результат шаблона проверяется, чтобы увидеть, есть ли там более одного элемента. Для тегов результат будет разделен на части, если calibre найдет запятую. Например, если в шаблоне выдается значение ``Thriller, Horror``, результатом будут два тега: ``Thriller`` и ``Horror``. Невозможно поставить запятую в середине тега.

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.
ru: То же самое происходит с авторами, но с использованием другого символа для сокращения, `&` (амперсанд) вместо запятой. Например, если в шаблоне указано значение ``Blogs, Joe&Posts, Susan``, тогда в книге будет два автора: ``Blogs, Joe`` и ``Posts, Susan``. Если шаблон выдает значение ``Blogs, Joe;Posts, Susan``, то у книги будет один автор с довольно странным именем.

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.
ru: Плагины влияют на метаданные, записанные в книгу, когда они сохраняются на диск или записываются на устройство. Плагины не влияют на метаданные, используемые командами «сохранить на диск» и «отправить на устройство» для создания имен файлов. Вместо этого имена файлов создаются с использованием шаблонов, введенных в соответствующем окне настроек.

en: Using functions in templates - Single Function Mode
ru: Использование функций в шаблонах - режим одной функции

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()}``.
ru: Предположим, вы хотите отобразить значение поля в верхнем регистре, когда это поле обычно находится в регистре заголовков. Вы можете сделать это с помощью шаблонных функций. Например, чтобы отобразить заголовок в верхнем регистре, используйте функцию ``uppercase``, как в ``{title:uppercase()}``. Чтобы отобразить его в регистре заголовка, используйте ``{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.
ru: Функции входят в форматную часть шаблона после ``:`` и перед первым ``|`` или закрывающим ``}``, если не используется префикс/суффикс. Если у вас есть и формат, и ссылка на функцию, функция появляется после второго ``:``. Функции возвращают соответствующее измененное значение столбца, указанного в шаблоне.

en: The syntax for using functions is one of::
ru: Синтаксис использования функций - один из::

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.
ru: За именами функций всегда должны стоять открывающие и закрывающие круглые скобки. Некоторым функциям требуются дополнительные значения (аргументы), и они заключаются в круглые скобки. Аргументы разделяются запятыми. Буквальным запятым (запятым как тексту, а не разделителям аргументов) должна предшествовать обратная косая черта (``\\``). Последний (или единственный) аргумент не может содержать закрывающую текстовую скобку.

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.
ru: Функции оцениваются до спецификации формата и префикса/суффикса. См. Ниже пример использования формата и функции.

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.
ru: **Важно**: если у вас есть опыт программирования, обратите внимание, что синтаксис в `Single Function Mode` не соответствует вашим ожиданиям. Строки не заключаются в кавычки, а пробелы имеют значение. Все аргументы считаются константами; нет выражений.

en: **Do not use subtemplates (`{ ... }`) as function arguments.** Instead, use :ref:`Template Program Mode <template_mode>` and :ref:`General Program Mode <general_mode>`.
ru: **Не используйте подшаблоны (`{ ... }`) в качестве аргументов функции.** Вместо этого используйте :ref:`Template Program Mode <template_mode>` и :ref:`General Program Mode <general_mode>`.

en: Notes on calling functions in Single Function Mode:
ru: Примечания по вызову функций в режиме одиночной функции:

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.
ru: Когда функции используются в режиме одиночной функции, первый параметр, ``value``, автоматически заменяется содержимым поля, указанного в шаблоне. Например, когда обрабатывается шаблон ``{title:capitalize()}``, содержимое поля ``title`` передается в качестве параметра ``value`` функции 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).
ru: В документации по функциям ниже обозначение ``[something]*`` означает, что ``something`` может повторяться ноль или более раз. Обозначение ``[something]+`` означает, что ``something`` повторяется один или несколько раз (должно существовать хотя бы один раз).

en: Some functions use regular expressions. In the template language regular expression matching is case-insensitive.
ru: Некоторые функции используют регулярные выражения. В языке шаблонов сопоставление регулярных выражений не зависит от регистра.

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.
ru: Функции задокументированы в :ref:`template_functions_reference`. В документации указано, какие аргументы требуются функциям и что они делают. Например, вот документация функции :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::
ru: Вы видите, что для функции требуется два аргумента: ``value`` и ``text_if_empty``. Однако, поскольку мы используем режим одиночной функции, мы опускаем аргумент ``value``, передавая только ``text_if_empty``. Например, этот шаблон::

en: shows the tags for a book, if any. If it has no tags then it show `No tags on this book`.
ru: показывает теги для книги, если таковые имеются. Если у неё нет тегов, то отображается `В этой книге нет тегов`.

en: The following functions are usable in Single Function Mode because their first parameter is ``value``.
ru: Следующие функции можно использовать в режиме одиночной функции, поскольку их первым параметром является ``value``.

en: **Using functions and formatting in the same template**
ru: **Использование функций и форматирования в одном шаблоне**

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::
ru: Предположим, у вас есть целочисленный настраиваемый столбец ``#myint``, который вы хотите отображать с ведущими нулями, как в ``003``. Один из способов сделать это - использовать формат 03. Однако по умолчанию, если число (целое или с плавающей запятой) равно нулю, тогда значение отображается как пустая строка, поэтому нулевые значения будут давать пустую строку, а не ``000``. Если вы хотите увидеть значения ``000``, используйте как строку формата, так и функцию ifempty, чтобы изменить пустое значение обратно в ноль. Шаблон будет::

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::
ru: Обратите внимание, что вы также можете использовать префикс и суффикс. Если вы хотите, чтобы номер отображался как ``[003]`` или ``[000]``, то используйте шаблон::

en: General Program Mode
ru: Общий программный режим

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::
ru: ``Общий программный режим`` (``GPM``) заменяет ``шаблонные выражения``  программой, написанной на ``языке шаблонов``. Синтаксис языка определяется следующей грамматикой::

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``.
ru: ``top_expression`` всегда имеет значение. Значение ``expression_list`` - это значение последнего ``top_expression`` в списке. Например, значение списка выражений ``1;2;'foobar';3`` равно ``3``.

en: In a logical context, any non-empty value is ``True``
ru: В логическом контексте любое непустое значение - ``True``

en: In a logical context, the empty value is ``False``
ru: В логическом контексте пустым значением является ``False``

en: Strings and numbers can be used interchangeably. For example, ``10`` and ``'10'`` are the same thing.
ru: Строки и числа могут использоваться как взаимозаменяемые. Например, ``10`` и ``'10'`` - это одно и то же.

en: Comments are lines starting with a '#' character, possibly preceded by blanks or tabs.
ru: Комментарии - это строки, начинающиеся с символа '#', возможно, перед ними стоят пробелы или табуляции.

en: **Operator precedence**
ru: **Приоритет оператора**

en: The operator precedence (order of evaluation) from highest (evaluated first) to lowest (evaluated last) is:
ru: Приоритет оператора (порядок оценки) от наивысшего (оценивается первым) до самого низкого (оценивается последним):

en: Function calls, constants, parenthesized expressions, statement expressions, assignment expressions, field references.
ru: Вызовы функций, константы, выражения в скобках, выражения операторов, выражения присваивания, ссылки на поля.

en: Unary plus (``+``) and minus (``-``). These operators evaluate right to left.
ru: Унарный плюс (``+``) и минус (``-``). Эти операторы вычисляют справа налево.

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``.
ru: Эти и все другие арифметические операторы возвращают целые числа, если результат выражения дает дробную часть, равную нулю. Например, если выражение возвращает ``3.0``, оно изменяется на ``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.
ru: Умножение (``*``) и деление (``/``). Эти операторы ассоциативны и выполняются слева направо. Используйте круглые скобки, если хотите изменить порядок оценки.

en: Add (``+``) and subtract (``-``). These operators are associative and evaluate left to right.
ru: Сложение (``+``) и вычитание (``-``). Эти операторы ассоциативны и выполняются слева направо.

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.
ru: Числовые и строковые сравнения. Эти операторы возвращают ``1``, если сравнение прошло успешно, в противном случае - пустую строку (``''``). Сравнения не ассоциативны: ``a < b < c`` - синтаксическая ошибка.

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.
ru: Конкатенация строк (``&``). Оператор ``&`` возвращает строку сформированную путем объединения левого и правого выражений. Пример: ``'aaa' & 'bbb'` возвращает ``'aaabbb'``. Оператор является ассоциативным и оценивает слева направо.

en: Unary logical not (``!``). This operator returns ``'1'`` if the expression is False (evaluates to the empty string), otherwise ``''``.
ru: Унарное логическое НЕ (``!``). Этот оператор возвращает ``'1'``, если выражение ложно (возвращает пустую строку), в противном случае ``''``.

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>`_.
ru: Логическое и (``&&``). Этот оператор возвращает '1', если и левое, и правое выражения имеют значение True, или пустую строку ``''``, если любое из них имеет значение False. Он ассоциативен, вычисляется слева направо и выполняет `short-circuiting `_.

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.
ru: Логическое ИЛИ (``||``). Этот оператор возвращает ``1``, если левое или правое выражение истинно, или ``''``, если оба ложны. Он ассоциативен, вычисляется слева направо и выполняет `short-circuiting `_. Это `включающее ИЛИ`, возвращающее``'1'``, если и левое, и правое выражения истинны.

en: **Field references**
ru: **Ссылки на поля**

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::
ru: ``field_reference`` оценивает значение поля метаданных, названного именем поиска, которое следует за ``$`` или ``$$``. Использование ``$`` эквивалентно использованию функции :ref:`field`. Использование ``$$`` эквивалентно использованию функции :ref:`ff_raw_field`. Примеры::

en: **If expressions**
ru: **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.
ru: Выражения ``if`` сначала оценивают условие. Если ``condition`` равно True (непустое значение), тогда ``expression_list`` в предложении ``then`` оценивается. Если оно равно False, то при его наличии вычисляется список выражений в предложении ``elif`` или ``else``. Части ``elif`` и ``else`` не являются обязательными. Слова ``if``, ``then``, ``elif``, ``else`` и ``fi`` зарезервированы; вы не можете использовать их в качестве имен идентификаторов. Вы можете помещать символы новой строки и пробелы везде, где они имеют смысл. ``condition`` - это ``top_expression``, а не ``expression_list``; точки с запятой не допускаются. ``expression_list`` - это разделенные точкой с запятой последовательности «top_expressions». Выражение ``if`` возвращает результат последнего выражения ``top_expression`` в вычисленном списке выражений или пустую строку, если список выражений не оценивался.

en: Examples::
ru: Примеры::

en: Nested ``if`` example::
ru: Пример вложенного ``if``::

en: As said above, an ``if`` produces a value. This means that all the following are equivalent::
ru: Как сказано выше, ``if`` выдаёт значение. Это означает, что всё следующее эквивалентно::

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::
ru: К примеру эта программа возвращает значение столбца ``series``, если в книге есть серия, в противном случае значение столбца ``title``::

en: **For expressions**
ru: **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.
ru: Выражение ``for`` выполняет итерацию по списку значений, обрабатывая их по одному за раз. ``list_expression`` должно соответствовать либо полю метаданных ``lookup name``, например, ``tags`` или ``#genre``, либо списку значений. Параметр :ref: `ff_range` генерирует список чисел. Если результатом является допустимое ``lookup name``, то извлекается значение поля и используется разделитель, указанный для этого типа поля. Если результатом не является допустимое имя для поиска, то предполагается, что это список значений. Предполагается, что список разделяется запятыми, если не указано необязательное ключевое слово ``separator``, и в этом случае значения списка должны быть разделены результатом вычисления ``separator_expr``. Разделитель нельзя использовать, если список генерируется с помощью ``range()``. Каждое значение в списке присваивается указанной переменной, после чего вычисляется ``expression_list``. Вы можете использовать ``break``, чтобы выйти из цикла, и ``continue``, чтобы перейти к началу цикла для следующей итерации.

en: Example: This template removes the first hierarchical name for each value in Genre (``#genre``), constructing a list with the new names::
ru: Пример: этот шаблон удаляет первое иерархическое имя для каждого значения в жанре (``#genre``), создавая список с новыми именами::

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.
ru: Если исходный жанр -  `History.Military, Science Fiction.Alternate History, ReadMe`, то шаблон возвращает `Military, Alternate History, ReadMe`. Вы можете использовать этот шаблон в calibre :guilabel:`Массовое редактирование метаданных - Поиск и замена` с помощью: guilabel:` Search for`, установленного на ``template``, чтобы удалить первый уровень иерархии и присвоить полученное значение Жанру.

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``.
ru: Примечание: последняя строка в шаблоне, ``new_tags``, в этом случае не является строго необходимой, потому что ``for`` возвращает значение последнего ``top_expression`` в списке выражений. Значение присваивания - это значение его выражения, поэтому значение оператора ``for`` - это то, что было присвоено ``new_tags``.

en: **Function definition**
ru: **Определение функции**

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.
ru: Если у вас есть повторяющийся код в шаблоне, вы можете поместить этот код в локальную функцию. Ключевое слово ``def`` запускает определение. За ним следует имя функции, список аргументов, затем код функции. Определение функции заканчивается ключевым словом ``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.
ru: Аргументы позиционные. При вызове функции предоставленные аргументы сопоставляются слева направо с определенными параметрами, при этом значение аргумента присваивается параметру. Будет ошибкой указывать больше аргументов, чем определено параметров. Параметры могут иметь значения по умолчанию, например ``a = 25``. Если для этого параметра не указан аргумент, используется значение по умолчанию, в противном случае параметру присваивается пустая строка.

en: The ``return`` statement can be used in a local function.
ru: Оператор ``return`` можно использовать в локальной функции.

en: A function must be defined before it can be used.
ru: Функция должна быть определена до того, как её можно будет использовать.

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::
ru: Пример. Этот шаблон вычисляет приблизительную продолжительность в годах, месяцах и днях из числа дней. Функция ``to_plural()`` форматирует вычисляемые значения. Обратите внимание, что в примере также используется оператор ``&``::

en: **Relational operators**
ru: **Операторы отношения**

en: Relational operators return ``'1'`` if the comparison is true, otherwise the empty string (``''``).
ru: Операторы отношения возвращают ``'1'``, если сравнение истинно, в противном случае - пустую строку (``''``).

en: There are two forms of relational operators: string comparisons and numeric comparisons.
ru: Есть две формы операторов отношения: сравнение строк и сравнение чисел.

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.
ru: При сравнении строк выполняется сравнение строк без учета регистра с использованием лексического порядка. Поддерживаемые операторы сравнения строк:  ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``, ``in`` и ``inlist``. Для оператора ``in`` результат левого выражения интерпретируется как шаблон регулярного выражения. Они являются истинными, если значение регулярного выражения слева совпадает со значением выражения справа. Регулярные выражения не чувствительны к регистру.

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.
ru: Оператор ``inlist`` имеет значение true, если левое регулярное выражение соответствует любому из элементов в правом списке, где элементы в списке разделены запятыми. Оператор ``inlist_field`` имеет значение true, если левое регулярное выражение соответствует любому из элементов в поле (столбце), названном правым выражением, используя разделитель, определённый для поля. ПРИМЕЧАНИЕ: оператор ``inlist_field`` требует, чтобы правое выражение преобразовывалось в имя поля, в то время как оператор ``inlist`` требует, чтобы правое выражение преобразовывалось в строку, содержащую список, разделённый запятыми. Из-за этого различия ``inlist_field`` выполняется существенно быстрее, чем ``inlist``, поскольку не выполняются преобразования строк или построения списков.

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.
ru: Операторы сравнения чисел: ``==#``, ``!=#``, ``<#``, ``<=#``, ``>#``, ``>=#``. Левое и правое выражения должны оцениваться как числовые значения с двумя исключениями: как строковое значение "None" (неопределенное поле), так и пустая строка оцениваются как нулевое значение.

en: Examples:
ru: Примеры:

en: ``program: field('series') == 'foo'`` returns ``'1'`` if the book's series is `foo`, otherwise ``''``.
ru: ``program: field('series') == 'foo'`` возвращает ``'1'`` если серия книги - `foo`, иначе - ``''``.

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 ``''``.
ru: ``program: 'f.o' in field('series')`` вернёт ``'1'`` если серия книги соответствует регулярному выражению ``f.o`` (например, `foo`, `Off Onyx` и т. д.), иначе ``''``.

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 ``''``.
ru: ``program: 'science' inlist $#genre`` вернёт ``'1'`` если какой-либо из жанров книги соответствует регулярному выражению ``science``, например, `Science`, `History of Science`, `Science Fiction` и т. д.), иначе ``''``.

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.
ru: ``program: '^science$' inlist $#genre`` вернёт ``'1'`` если какой-либо из жанров книги точно соответствует регулярному выражению ``^science$``, например `Science`. Жанры `History of Science` и `Science Fiction` не совпадают.

en: ``program: 'asimov' inlist $authors`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
ru: ``program: 'asimov' inlist $authors`` вернёт ``'1'`` если какой-либо автор соответствует регулярному выражению ``asimov``, например, `Asimov, Isaac` или `Isaac Asimov`, иначе ``''``.

en: ``program: 'asimov' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
ru: ``program: 'asimov' inlist_field 'authors'`` вернёт ``'1'`` если какой-либо автор соответствует регулярному выражению ``asimov``, например, `Asimov, Isaac` или `Isaac Asimov`, иначе ``''``.

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.
ru: ``program: 'asimov$' inlist_field 'authors'`` вернёт ``'1'`` если какой-либо автор соответствует регулярному выражению ``asimov$``, например, `Isaac Asimov`, иначе ``''``. Это не соответствует `Asimov, Isaac` из-за привязки ``$`` в регулярном выражении.

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'``.
ru: ``program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` returns ``'bar'`` если серия книги не ``foo``. Иначе возвращается ``'mumble'``.

en: ``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
ru: ``program: if '^(foo|1632)$'  field('series') then 'yes' else 'no' fi`` returns ``'yes'`` if series is either ``'foo'`` or ``'1632'``, otherwise ``'no'``.

en: ``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the ``>`` operator does a lexical comparison.
ru: ``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the ``>`` оператор выполняет лексическое сравнение.

en: ``program: if 11 ># 2 then 'yes' else 'no' fi`` returns ``'yes'`` because the ``>#`` operator does a numeric comparison.
ru: ``program: if 11 ># 2 then 'yes' else 'no' fi`` вернёт ``'yes'``  потому что оператор  ``>#`` выполняет числовое сравнение.

en: **Functions in General Program Mode**
ru: **Функции в Общем программном режиме**

en: See :ref:`template_functions_reference` for the list of functions built into the template language.
ru: Смотрите :ref:`template_functions_reference` для получения списка функций, встроенных в язык шаблонов.

en: As opposed to :ref:`Single Function Mode <single_mode>`, in General Program Mode you must specify the first parameter ``value``.
ru: В отличие от :ref:`Single Function Mode <single_mode>`, в Общем программном режиме вы должны указать первый параметр ``value``.

en: All parameters are expression_lists (see the grammar above).
ru: Все параметры являются expression_lists (смотрите грамматику выше).

en: More complex programs in template expressions - Template Program Mode
ru: Более сложные программы в шаблонных выражениях - Template Program Mode

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.
ru: `Template Program Mode` (`TPM`) - смесь :ref:`General Program Mode` и :ref:` Single Function Mode`. TPM отличается от режима одиночной функции тем, что он позволяет писать шаблонные выражения, которые ссылаются на другие поля метаданных, используют вложенные функции, изменяют переменные и выполняют арифметические операции. Он отличается от `General Program Mode` тем, что шаблон заключен между символами``{`` и``}``и не начинается со слова ``program:``. Программная часть шаблона - это список выражений General Program Mode.

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::
ru: Пример: предположим, что вы хотите, чтобы шаблон отображал серию книги, если она есть, в противном случае показывала бы значение настраиваемого поля #genre. Вы не можете сделать это в :ref:`Single Function Mode <single_mode>`, потому что вы не можете ссылаться на другое поле метаданных в выражении шаблона. В `TPM` это можно сделать, как демонстрирует следующее выражение::

en: The example shows several things:
ru: Пример показывает несколько вещей:

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>`.
ru: `TPM` используется, если выражение начинается с ``:'`` и заканчивается ``'}``. Предполагается, что все остальное находится в :ref:`Single Function Mode<single_mode>`.

en: If the template contains a prefix and suffix, the expression ends with ``'|`` where the ``|`` is the delimiter for the prefix. Example::
ru: Если шаблон содержит префикс и суффикс, выражение заканчивается на ``'|``, где ``|`` является разделителем префикса. Пример::

en: Functions must be given all their arguments. For example, the standard built-in functions must be given the initial parameter ``value``.
ru: функциям должны быть даны все их аргументы. Например, стандартные встроенные функции должны иметь дополнительный начальный параметр ``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.
ru: Переменная `$` может использоваться в качестве аргумента ``value`` и обозначает значение поля с именем в шаблоне, в данном случае ``series``.

en: white space is ignored and can be used anywhere within the expression.
ru: пробелы игнорируются и могут использоваться в любом месте выражения.

en: constant strings are enclosed in matching quotes, either ``'`` or ``"``.
ru: константные строки заключаются в соответствующие кавычки, либо ``'``, либо ``''``.

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`.
ru: В `TPM` использование символов ``{`` и ``}`` в строковых литералах может привести к ошибкам или неожиданным результатам, поскольку они сбивают с толку обработчик шаблонов. Он пытается рассматривать их как границы выражения шаблона, а не как символы. В некоторых, но не во всех случаях, вы можете заменить ``{`` на ``[[`` и ``}`` на ``]]``. Как правило, если ваша программа содержит символы ``{`` и ​​``}``, вам следует использовать `General Program Mode`.

en: Python Template Mode
ru: Режим шаблона 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.
ru: Режим шаблонов Python (PTM) позволяет создавать шаблоны с использованием родного Python и `calibre API <https://manual.calibre-ebook.com/develop.html#api-documentation-for-various-parts-of-calibre>`_. API базы данных будет наиболее полезным; дальнейшее обсуждение выходит за рамки данного руководства. Шаблоны PTM быстрее и могут выполнять более сложные операции, но вы должны знать, как писать код на Python, используя calibre API.

en: A PTM template begins with:
ru: Шаблон PTM начинается с:

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.
ru: Вы можете добавить приведенный выше текст в свой шаблон с помощью контекстного меню, доступ к которому обычно осуществляется с помощью щелчка правой кнопкой мыши. Комментарии несущественны и могут быть удалены. Вы должны использовать отступы 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.
ru: Объект контекста поддерживает ``str(context)``, который возвращает строку содержимого контекста, и ``context.attributes``, который возвращает список имён атрибутов в контексте.

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:
ru: Атрибут ``context.funcs`` позволяет вызывать встроенные и пользовательские функции шаблонов, а также Сохранённые шаблоны GPM/Python, чтобы вы могли выполнять их непосредственно в своем коде. Функции извлекаются по их именам. Если имя конфликтует с ключевым словом Python, добавьте в конце имени символ подчеркивания. Примеры:

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.
ru: Вот пример шаблона PTM, который создает список всех авторов серии. Список хранится как  `Столбец, состоящий из других столбцов, ведущих себя как теги`. Он отображается в :guilabel:`Описание книги` и отмечен как :guilabel:`Категории в отдельных строках` (в :guilabel:`Настройки->Оформление->Описание книги`). Этот параметр требует, чтобы список был разделён запятыми. Чтобы удовлетворить это требование, шаблон преобразует запятые в именах авторов в точки с запятой, а затем создаёт список авторов, разделённых запятыми. Затем авторы сортируются, поэтому в шаблоне используется author_sort.

en: The output in :guilabel:`Book details` looks like this:
ru: Вывод в :guilabel:`Описание книги` выглядит так:

en: E-book conversion dialog
ru: Диалог конвертации электронной книги

en: Templates and URLs
ru: Шаблоны и URL

en: You can use templates to construct URLs. Two cases are described here:
ru: Вы можете использовать шаблоны для создания URL-адресов. Здесь описаны два случая:

en: Custom column :guilabel:`Book details` search URLs
ru: Пользовательский столбец: :guilabel:`Book details guilabel: URL-адреса

en: The calibre URL scheme
ru: Схема URL-адресов calibre

en: **Custom column book details search URLs**
ru: **пользовательский столбец URL-адреса для поиска сведений о книге**

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.
ru: Когда вы создаете пользовательский столбец, вы можете указать URL-адрес, который будет использоваться в :guilabel:`Сведения о книге`, используя шаблон. Например, если у вас есть пользовательский столбец для `Translators`, вы можете определить URL-адрес, который приведет вас на сайт для переводчиков. URL-адреса для поиска сведений о книге могут быть предоставлены для типов столбцов `Текст`, `Перечисляемый', 'Серия' и 'Столбец, построенный из других столбцов`.

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:
ru: При нажатии на элемент с `шаблоном поиска` в :guilabel:`Сведения о книге` шаблон оценивается. Ему предоставляются обычные метаданные книги. Также предоставляются три дополнительных поля:

en: ``item_value``: the value of the clicked item.
ru: ``item_value``: значение нажатого элемента.

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.
ru: ``item_value_quoted``: значение нажатого элемента, кодированный URL. Специальные символы экранируются, чтобы сделать их действительными в URL-адресах, а пробелы заменяются на знаки ``'+'`` (плюс).

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.
ru: ``item_value_no_plus``: значение нажатого элемента, кодированный URL. Специальные символы экранируются, чтобы сделать их действительными в URL-адресах, а пробелы заменяются на знаки ``'+'`` (плюс).

en: There are several ways to construct the URL. The following use Wikipedia as an example.
ru: Существует несколько способов создания URL-адреса. Ниже в качестве примера используется Википедия.

en: The simplest is a basic template::
ru: Самый простой - это базовый шаблон::

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.
ru: В некоторых случаях может потребоваться дополнительная обработка. В зависимости от сложности обработки вы можете использовать четыре шаблонные функции.

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::
ru: Например, предположим, что у вас есть пользовательский столбец `Переводчики` (``#translators``), где имена - `Last name, First name`. Возможно, при создании URL-адреса вам потребуется преобразовать имя в `First name Last name`. Для этого вы можете использовать функцию :ref: `ff_make_url`::

en: If we assume that the translator's name is `Boy-Żeleński, Tadeusz` then the above template produces the link::
ru: Если мы предположим, что переводчика зовут `Boy-Żeleński, Tadeusz`, то приведенный выше шаблон выдает ссылку::

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.
ru: Обратите внимание, что имя пользователя теперь стоит первым, пробел - это плюс, а неанглоязычные символы в фамилии 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.
ru: Функции :ref:`ff_make_url_extended`, :ref:`ff_query_string` и :ref:`ff_encode_for_url` могут быть полезны в зависимости от любой дополнительной сложности обработки.

en: **The calibre URL scheme**
ru: **Схема URL-адресов 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.
ru: Calibre поддерживает несколько различных URL-адресов для навигации по вашим библиотекам calibre. В этом разделе показано, как использовать шаблоны для создания URL-адресов. Смотрите :doc:`url_scheme` для получения подробной информации о доступных URL-адресах.

en: Switch to a specific library. The syntax of this URL is::
ru: Переключение на определённую библиотеку. Синтаксис этого URL-адреса следующий::

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::
ru: ``Library_Name`` необходимо заменить на название библиотеки calibre, которую вы хотите открыть. Название библиотеки отображается в строке заголовка окна. Это простое имя, а не путь к файлу библиотеки. Вы должны написать его так, как показано в строке заголовка, включая регистр букв. Символ ``_`` (подчеркивание) обозначает текущую библиотеку. Если имя содержит какие-либо пробелы или специальные символы, то оно должно быть закодировано в шестнадцатеричном формате с использованием функции :ref:`ff_to_hex`, как в следующем примере::

en: The template generates the URL::
ru: Шаблон генерирует URL-адрес::

en: You can replace the ``current_library_name()`` function with the actual name of the library, as in::
ru: Вы можете заменить функцию ``current_library_name()`` фактическим именем библиотеки, как в::

en: Links to show books. These links select a book in the calibre library. The syntax for this URL is::
ru: Ссылки для показа книг. По этим ссылкам выбирается книга в библиотеке calibre. Синтаксис этого URL-адреса следующий::

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::
ru: ``book id`` - это цифровой идентификатор книги в calibre, доступный в шаблонах как ``$ id``. Как указано выше, название библиотеки может потребоваться в шестнадцатеричном кодировании. Вот пример::

en: It produces the URL::
ru: Он выдает URL-адрес::

en: Searching for books. These links search for books in the specified calibre library. The syntax for this URL is::
ru: Поиск книг. Эти ссылки выполняют поиск книг в указанной библиотеке calibre. Синтаксис этого URL-адреса следующий::

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::
ru: где `query` - любое допустимое поисковое выражение calibre. Вы должны закодировать любой запрос, содержащий пробелы или специальные символы, в шестнадцатеричном формате, что обычно означает их все. Например, поисковое выражение calibre для поиска иерархического тега, начинающегося с 'AA', является ``tags:"=.AA"``. Этот шаблон создает URL-адрес поиска для этого выражения::

en: The resulting URL is::
ru: Результирующий URL-адрес выглядит следующим образом::

en: Here is an example of the same URL built using the :ref:``ff_make_url_extended`` function instead of :ref:`ff_strcat`::
ru: Вот пример того же URL, созданного с использованием функции :ref:``ff_make_url_extended`` вместо :ref:``ff_strcat``::

en: Open a book details window on a book in some library. The syntax for this URL is::
ru: Открыть окно сведений о книге в какой-либо библиотеке. Синтаксис этого URL-адреса следующий::

en: An example template is::
ru: Примером шаблона является::

en: which produces the URL::
ru: который выдает URL-адрес::

en: Open the notes associated with an author/series/etc. The syntax of the URL is::
ru: Открыть примечания, связанные с автором/серией/и т.д. Синтаксис URL-адреса следующий::

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``::
ru: ``Field_Name`` - это поисковое имя поля. Если поле представляет собой пользовательский столбец, замените символ ``#`` символом подчеркивания (``_``). ``Item_Id`` - это внутренний числовой идентификатор значения в поле. Не существует шаблонной функции, которая возвращала бы ``Item_Id``, поэтому шаблоны обычно используют вторую форму, ``Hex_Encoded_Item_Name``. Вот образец шаблона, который открывает заметку для человека ``Boy-Żeleński, Tadeusz`` в поле ``#authtest``::

en: Stored templates
ru: Сохранённые шаблоны

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``:
ru: И :ref:`Общий программный режим <general_mode>`, и :ref:`Режим шаблона Python <python_mode>` поддерживают сохранение шаблонов и вызов этих шаблонов из другого шаблона, во многом аналогично вызову хранимых функций. Вы сохраняете шаблоны, используя :guilabel:`Настройки->Расширенные->Шаблонные функции`. В этом диалоговом окне - ​​дополнительная информация. Вы вызываете шаблон так же, как вызываете функцию, передавая позиционные аргументы, если необходимо. Аргументом может быть любое выражение. Примеры вызова шаблона, предполагая, что сохраненный шаблон называется ``foo``:

en: ``foo()`` -- call the template passing no arguments.
ru: ``foo()`` -- вызов шаблона без аргументов.

en: ``foo(a, b)`` call the template passing the values of the two variables ``a`` and ``b``.
ru: ``foo(a, b)`` вызывает шаблон, передавая значения переменных ``a`` и ``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``.
ru: ``foo(if field('series') then field('series_index') else 0 fi)`` -- если в книге есть ``series``, то передать ``series_index``, в противном случае - значение ``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``::
ru: В GPM вы извлекаете аргументы, переданные при вызове сохраненного шаблона, с помощью функции ``arguments``. Она и объявляет, и инициализирует локальные переменные, фактически параметры. Переменные являются позиционными; они получают значение параметра, заданного при вызове, в той же позиции. Если соответствующий параметр не указан в вызове, тогда ``arguments`` присваивает этой переменной предоставленное значение по умолчанию. Если значение по умолчанию отсутствует, переменной присваивается пустая строка. Например, следующая функция ``arguments`` объявляет 2 переменные, ``key``, ``alternate``::

en: Examples, again assuming the stored template is named ``foo``:
ru: Примеры, снова предполагаем, что сохраненный шаблон назван ``foo``:

en: ``foo('#myseries')`` -- argument ``key`` is assigned the value ``'myseries'`` and the argument ``alternate`` is assigned the default value ``'series'``.
ru: ``foo('#myseries')`` -- аргументу ``key`` присваивается значение ``'myseries'``, а аргументу ``alternate`` присваивается значение по умолчанию ``'series'``.

en: ``foo('series', '#genre')`` the variable ``key`` is assigned the value ``'series'`` and the variable ``alternate`` is assigned the value ``'#genre'``.
ru: ``foo('series', '#genre') переменной ``key`` присваивается значение ``'series'``, а переменной ``alternate`` присваивается значение ``'#genre'``.

en: ``foo()`` -- the variable ``key`` is assigned the empty string and the variable ``alternate`` is assigned the value ``'series'``.
ru: ``foo()`` - переменной ``key`` присваивается пустая строка, а переменной ``alternate`` присваивается значение ``'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.
ru: В PTM аргументы передаются в параметре ``arguments``, который представляет собой список строк. Невозможно указать значения по умолчанию. Вы должны проверить длину списка ``аргументов``, чтобы убедиться, что количество аргументов соответствует ожидаемому.

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.
ru: Простой способ проверить сохраненные шаблоны - использовать диалоговое окно ``Тестер шаблонов``. Для облегчения доступа используйте сочетание клавиш в :guilabel:`Preferences-Advanced-Keyboard shortcuts-Template tester`. Ярлык для диалогового окна ``Сохраненные шаблоны``' поможет быстрее переключаться между тестером и редактированием исходного кода сохраненного шаблона.

en: Providing additional information to templates
ru: Передача шаблонам дополнительной информации

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.
ru: Разработчик может выбрать передачу дополнительной информации процессору шаблонов, например метаданные книги для конкретного приложения или информацию о том, что процессору предлагается сделать. Шаблон может получить доступ к этой информации и использовать ее во время оценки.

en: **Developer: how to pass additional information**
ru: ** Разработчик: как передать дополнительную информацию **

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.
ru: Дополнительная информация - это словарь ``dict`` Python, содержащий пары ``variable_name: variable_value``, где значения должны быть строками. Шаблон может получить доступ к ``dict``, создавая локальные переменные шаблона с именем ``variable_name``, содержащие значение ``variable_value``. Пользователь не может изменить имя, поэтому лучше использовать имена, которые не будут конфликтовать с другими локальными переменными шаблона, например, добавив к имени префикс подчеркивания _.

en: This dictionary is passed to the template processor (the ``formatter``) using the named parameter ``global_vars=your_dict``. The full method signature is::
ru: Этот dict передается процессору шаблонов (``formatter``) с использованием именованного параметра ``global_vars=your_dict``. Полная сигнатура метода::

en: **Template writer: how to access the additional information**
ru: ** Автор шаблона: как получить доступ к дополнительной информации **

en: You access the additional information (the ``globals`` dictionary) in a template using the template function::
ru: Вы получаете доступ к дополнительной информации (словарю ``globals``) в шаблоне с помощью шаблонной функции::

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.
ru: где ``id`` - любое допустимое имя переменной. Эта функция проверяет, содержит ли дополнительная информация, предоставленная разработчиком, имя. Если это так, функция присваивает предоставленное значение локальной переменной шаблона с этим именем. Если имя отсутствует в дополнительной информации и если предоставлено ``expression``, то ``expression`` оценивается, и результат присваивается локальной переменной. Если ни значение, ни выражение не предоставлены, функция присваивает пустую строку  (``''``) локальной переменной.

en: A template can set a value in the ``globals`` dictionary using the template function::
ru: Шаблон может установить значение в словаре ``globals`` с помощью шаблонной функции::

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``.
ru: Эта функция устанавливает ``globals`` dict key:value пару ``id:value``, где ``value`` - значение шаблонной локальной переменной ``id``. Если эта локальная переменная не существует, тогда ``value`` устанавливается равным результату вычисления выражения ``expression``.

en: Notes on the difference between modes
ru: Замечания о разнице между режимами

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.
ru: Три программных режима :ref:`Single Function Mode <single_mode>` (SFM), :ref:`Template Program Mode <template_mode>` (`TPM`) и :ref:`General Program Mode <general_mode>` (`GPM`) работают по-разному. SFM задуман как 'простой', поэтому он скрывает много тонкостей в языке программирования.

en: Differences:
ru: Различия:

en: In SFM the value of the column is always passed as an 'invisible' first argument to a function included in the template.
ru: В SFM значение столбца всегда передается как 'invisible' «невидимый» первый аргумент функции, включенной в шаблон.

en: SFM doesn't support the difference between variables and strings; all values are strings.
ru: SFM не поддерживает разницу между переменными и строками; все значения являются строками.

en: The following SFM template returns either the series name or the string "no series"::
ru: Следующий шаблон SFM возвращает либо название серии, либо строку "no series"::

en: The equivalent template in `TPM` is ::
ru: Эквивалентный шаблон в `TPM` ::

en: The equivalent template in `GPM` is::
ru: Эквивалентный шаблон в `GPM` ::

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).
ru: Первый аргумент ``ifempty`` - это значение поля ``series``. Второй аргумент - это строка ``no series``. В SFM автоматически передается первый аргумент, значение поля (невидимый аргумент).

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.
ru: Некоторые функции-шаблоны, например, ``booksize()`` и ``current_library_name()``, не принимают аргументов. Из-за 'невидимого аргумента' вы не можете использовать эти функции в 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::
ru: Вложенные функции, когда функция вызывает другую функцию для вычисления аргумента, не могут использоваться в SFM. Например, этот шаблон, предназначенный для возврата первых 5 символов значения серии в верхнем регистре, не будет работать в SFM::

en: `TPM` and `GPM` support nested functions. The above template in `TPM` would be::
ru: `TPM` и `GPM` поддерживают вложенные функции. Вышеупомянутый шаблон в `TPM` будет::

en: In `GPM` it would be::
ru: В GPM это было бы::

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`.
ru: Как отмечалось выше в разделе :ref:`Template Program Mode`, использование символов ``{`` и``}`` в строковых литералах `TPM` может привести к ошибкам или неожиданным результатам, поскольку они сбивают с толку обработчик шаблонов. Он пытается рассматривать их как границы шаблона, а не как символы. В некоторых, но не во всех случаях, вы можете заменить ``{`` на ``[[`` и ``}`` на `]]`. Как правило, если ваша программа содержит символы ``{`` и ​​``}``, вам следует использовать `General Program Mode`.

en: User-defined Python template functions
ru: Пользовательские шаблонные функции Python

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.
ru: Вы можете добавить свои собственные функции Python в процессор шаблонов. Такие функции можно использовать в любом из трех режимов программирования шаблонов. Функции добавляются по ссылке: guilabel:`Настройки - Расширенные - Функции шаблонов`. Инструкции показаны в этом диалоговом окне. Обратите внимание, что вы можете использовать `Шаблоны Python` для аналогичной цели. Поскольку вызов пользовательских функций выполняется быстрее, чем вызов шаблона Python, пользовательские функции могут быть более эффективными в зависимости от сложности того, что выполняет функция или шаблон.

en: Special notes for using templates in different contexts
ru: Особые указания по использованию шаблонов в различных контекстах

en: In the GUI (:guilabel:`Columns made from other columns` and :guilabel:`Template searches`):
ru: В графическом интерфейсе (:guilabel:`Столбцы, созданные из других столбцов` и:guilabel:`Поиск по шаблону`):

en: GPM templates work as before.
ru: Шаблоны GPM работают по-прежнему.

en: Python templates have full access to the calibre database.
ru: Шаблон Python будет иметь полный доступ к базе данных calibre.

en: In icon rules:
ru: В правилах значков:

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.
ru: шаблоны правил значков не содержат данных книги, поэтому функции на основе полей, такие как :ref:`ff_format_date_field`, :ref:`ff_list_count_field`, и :ref:`ff_check_yes_no` не работают.

en: In the Content server:
ru: В контент-сервере:

en: Templates have access to the new API but not the old API (LibraryDatabase).
ru: Шаблоны имеют доступ к новому API, но не к старому API (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:
ru: Из-за вышесказанного, работа следующих функций форматирования в шаблонах GPM не гарантируется (составные столбцы, правила значков и т.д.), и их следует избегать, если вы используете контент-сервер:

en: Special notes for save/send templates
ru: Особые примечания для шаблонов сохранения/отправки

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.
ru: Специальная обработка применяется, когда шаблон используется в шаблоне :guilabel:`Save to disk` или :guilabel:`Send to device`. Значения полей очищаются, заменяя символы, специальные для файловых систем, подчеркиванием, включая косую черту. Это означает, что текст поля нельзя использовать для создания папок. Однако косые черты не изменяются в строках префиксов или суффиксов, поэтому косые черты в этих строках вызовут создание папок. Благодаря этому вы можете создать структуру папок переменной глубины.

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::
ru: Например, предположим, что нам нужна структура папок `series/series_index - title`, с оговоркой, что если серия не существует, то заголовок должен находиться в верхней папке. Шаблон для этого::

en: The slash and the hyphen appear only if series is not empty.
ru: Косая черта и дефис появляются только в том случае, если серия не пуста.

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.
ru: Функция поиска позволяет нам выполнять еще более интересную обработку. Например, предположим, что если в книге есть серия, то нам нужна структура папок `series/series index - title.fmt`. Если в книге нет серии, нам нужна структура папок `genre/author_sort/title.fmt`. Если у книги нет жанра, мы хотим использовать 'Unknown'. Нам нужны два совершенно разных пути, в зависимости от значения серии.

en: To accomplish this, we:
ru: Чтобы этого добиться, мы:

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`.
ru: Создать составное поле (дать ему имя для поиска #aa), содержащее ``{series}/{series_index} - {title}``. Если серия не пуста, тогда этот шаблон создаст `series/series_index - title`.

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`.
ru: Создать составное поле (дать ему имя для поиска #bb), содержащее ``{#genre: ifempty (Unknown)}/{author_sort}/{title}``. Этот шаблон создаст `genre /author_sort/title`, где пустой жанр заменяется на `Unknown`.

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.
ru: Установить для шаблона сохранения значение ``{series:lookup(.,#aa,#bb}``. Этот шаблон выбирает составное поле ``#aa``, если серия не пуста, и составное поле ``#bb``, если серия пуста, поэтому у нас есть два совершенно разных пути сохранения, в зависимости от того, пуста ли `series`.

en: Tips
ru: Советы

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.
ru: Используйте тестер шаблонов для тестирования шаблонов. Добавьте тестер в контекстное меню для книг в библиотеке и/или назначьте ему сочетание клавиш.

en: Templates can use other templates by referencing composite columns built with the desired template. Alternatively, you can use Stored Templates.
ru: Шаблоны могут использовать другие шаблоны, ссылаясь на составные столбцы, построенные с помощью желаемого шаблона. В качестве альтернативы вы можете использовать сохраненные шаблоны.

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.
ru: В коммутации полю можно назначить соответствующее его типу пустое значение при помощи специального шаблона ``{}``. Он всегда соответствует пустой строке.

en: The technique described above to show numbers even if they have a zero value works with the standard field series_index.
ru: Описанный выше метод отображения чисел, даже если они имеют нулевое значение, работает со стандартным полем series_index.

en: Template function reference
ru: Справочник по шаблонным функциям
