> For the complete documentation index, see [llms.txt](https://chatme-ai-4.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://chatme-ai-4.gitbook.io/docs/proekty-na-platforme/proekt-i-ego-soderzhimoe/agenty-na-platforme/sintaksis.md).

# Синтаксис

## Общая информация о синтаксисе

Синтаксис может использоваться в следующих Слотах:

* Text: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Text List
* Attachment: допустимо использование Выражение и Выражение с управляющей конструкцией в полях Source и Caption
* Slot Filling: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Question
* button:  допустимо использование Выражение в поле Label
* condition: допустимо использование Выражение в поле Condition
* Timer: допустимо использование Выражение в поле If
* Memory: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Value
* External Request: допустимо использование Выражение и Выражение с управляющей конструкцией в полях URL, Value на вкладке Headers и Query parameters, Data, поле Name на вкладке Response
* Incoming Request: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Value
* Synonym: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Source

\
Синтаксис Платформа использует синтаксис шаблонизатора Jinja:<https://jinja.palletsprojects.com/en/3.0.x/templates/>Шаблоны в синтаксисе делятся на 2 концепции:

1. Выражение. Заключаются в двойные фигурные скобки.
2. <https://jinja.palletsprojects.com/en/3.0.x/templates/#expressions>Примеры:
3. 1. {{ client\_message }}
   2. {{ number \* 10 }}
   3. {{ chat\_id == ‘abcde0123456789’ }}
   4. {{ uuid4() }}
   5. {{ some\_variable is defined }}
4. Выражение с управляющей конструкцией. Заключаются в фигурные скобки с символом %.<https://jinja.palletsprojects.com/en/3.0.x/templates/#list-of-control-structures>
5. Примеры:
6. 1. {% if client\_message == ‘привет’ %}Hi{% else %}Bye{% endif %}
   2. {% for number in \[1, 2, 3] %}{{ number }}{% endfor %}

| Тип данных          | Memory                                                                                                                                                                              | Примеры вывода в текстовом слоте                                                                                                                            | Примечание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                          |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| Строки              | <ul><li>{{ 'string' }}</li><li>{{ "string" }}</li><li>Пустая строка: {{ '' }} или {{ "" }}</li></ul>                                                                                | <p>string<br>Пустая строка выводится в виде отсутcтвия значения</p>                                                                                         | <p>Если строка обрамлена двойными кавычками и внутри строки присутствует символ двойных кавычек в качестве знака препинания, то символ кавычек внутри строки необходимо экранировать символом \ для прохождения Валидация сценария и корректного отображения. Пример:<br>{{ "кинотеатр "Победа" " }}<br>Если строка обрамлена одинарными кавычками и внутри строки присутствует символ одинарных кавычек в качестве знака препинания, то символ кавычек внутри строки необходимо экранировать символом \ для прохождения Валидация сценария и корректного отображения. Пример:<br>{{ 'I've made an order' }}<br>В случаях, когда строка обрамлена двойными кавычками и внутри строки присутствует символ одинарных кавычек, либо если строка обрамлена одинарными кавычками и внутри строки присутствует символ двойных кавычек, экранирование не требуется.</p> |                          |
| Числа               | <ul><li>{{ 5 }}</li><li>{{ 42.23 }}</li></ul>                                                                                                                                       | <ul><li>5</li><li>42.23</li></ul>                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                          |
| Булевы              | <ul><li>{{ true }}</li><li>{{ false }}</li></ul>                                                                                                                                    | <ul><li>True</li><li>False</li></ul>                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                          |
| Отсутствие значения | {{ None }}                                                                                                                                                                          | Выводится в виде отсутcтвия значения                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                          |
| Объекты             | {{ {"one": 1, "two": 2, "colors": \["red", "green", "blue"]} }}                                                                                                                     | {"one": 1, "two": 2, "colors": \["red", "green", "blue"]}                                                                                                   | В Платформа доступны Зарезервированные методы объектов: Зарезервированные методы объектов                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                          |
| Массивы             | <ul><li>Чисел: \[1, 2, 3, 4, 5]</li><li>Строк: \["one", "two", "three"]</li><li>Массивов: \[\["one", "two", "three"], \["cat", "dog", "bird"], \["green", "blue", "red"]]</li></ul> | <ul><li>\[1, 2, 3, 4, 5]</li><li>\["one", "two", "three"]</li><li>\[\['one', 'two', 'three'], \['cat', 'dog', 'bird'], \['green', 'blue', 'red']]</li></ul> | <ul><li>Через точку (.) происходит обращение к элементам массивов;</li><li>Обращение к соответствующему номеру элемента массива происходит с помощью чисел. Нумерация элементов массива начинается с нуля, поэтому обращение к первому элементу массива обозначается как 0.</li><li>Примеры: {{ array.0 }}</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                          |
| Даты                | <p>Привести данные к формату даты возможно только с помощью фильтра string\_to\_time<br>Пример: {{ "2000-06-15 18:50:47"                                                            | string\_to\_time("%Y-%m-%d %H:%M:%S") }}<br>Подробнее: Преобразование строки в дату</p>                                                                     | 2000-06-15 18:50:47                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Часовой пояс не хранится |

| Метод      | Доступность в Платформе | Смысл                                    | Как использовать    | Пример                   |                                                            |
| ---------- | ----------------------- | ---------------------------------------- | ------------------- | ------------------------ | ---------------------------------------------------------- |
| items      | Да                      | Возвращает пары "ключ-значение" словаря. | {{ data.items() }}  | <ul><li>{{ data.items()  | list }}</li><li>Результат: \[('a', 1), ('b', 2)]</li></ul> |
| keys       | Да                      | Возвращает ключи словаря                 | {{ data.keys() }}   | <ul><li>{{ data.keys()   | list }}</li><li>Результат: \['a', 'b']</li></ul>           |
| values     | Да                      | Возвращает значения словаря              | {{ data.values() }} | <ul><li>{{ data.values() | list }}</li><li>Результат: \[1, 2]</li></ul>               |
| clear      | Нет                     |                                          |                     |                          |                                                            |
| copy       | Нет                     |                                          |                     |                          |                                                            |
| fromkeys   | Нет                     |                                          |                     |                          |                                                            |
| get        | Нет                     |                                          |                     |                          |                                                            |
| pop        | Нет                     |                                          |                     |                          |                                                            |
| popitem    | Нет                     |                                          |                     |                          |                                                            |
| setdefault | Нет                     |                                          |                     |                          |                                                            |
| update     | Нет                     |                                          |                     |                          |                                                            |

> Важно: при парсинге Входящий запрос, ответа на Внешний запрос или на Notification обращение к ключу объекта, если его имя совпадает с именем Зарезервированные методы объектов происходит через квадратные скобки и кавычки.\
> Пример: {{ data\["keys"] }}

## Выражения

| Оператор        | Обозначение                                                                     | Область применения                                                                                                    | Как использовать                                                                                                                                                                                                                                                                                                                           | Пример                                                                                                                                                                                                                                                                                                                                                        |
| --------------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Строка          | "string"                                                                        | <ul><li>Объявление строки</li><li>Объявление пустой строки</li></ul>                                                  | <p>Объявление строки</p><ul><li>Пустая строка</li><li>{{ '' }} или {{ "" }}</li><li>Непустая строка</li><li>{{ 'str' }} или {{ "str" }}</li></ul><p>Обращение к символам строкиstr == {{ 'string' }}{{ str\[0] }} = s{{ str\[1] }} = t...Срез строкиstr == {{ 'string' }}{{ str\[:2] }} = st{{ str\[2:] }} = ring{{ str\[2:5] }} = rin</p> | <ul><li>{{ 'Hello World' }}</li><li>Результат: Hello World.</li><li>{{ "Hello World" }}</li><li>Результат: Hello World.</li><li>{{ 'Hello World'\[1] }}</li><li>Результат: e.</li><li>{{ 'Hello World'\[:5] }}</li><li>Результат: Hello.</li><li>{{ 'Hello World'\[5:] }}</li><li>Результат: World.</li></ul>                                                 |
| Целое число     | <ul><li>42</li><li>123\_456</li></ul>                                           | Объявление целого числа                                                                                               | {{ num }}                                                                                                                                                                                                                                                                                                                                  | <ul><li>{{ 123 }}</li><li>Результат: 123.</li><li>{{ 1\_2\_3 }}</li><li>Результат: 123.</li></ul>                                                                                                                                                                                                                                                             |
| Число с точкой  | <ul><li>42.23</li><li>42.1e2</li><li>123\_456.789</li></ul>                     | Объявление вещественного числа                                                                                        | {{ num }}                                                                                                                                                                                                                                                                                                                                  | <ul><li>{{ 42.23 }}</li><li>Результат: 42.23.</li><li>{{ 42.1e2 }}</li><li>Результат: 4210.0.</li><li>{{ 4\_2.23 }}</li><li>Результат: 42.23.</li></ul>                                                                                                                                                                                                       |
| Списки          | \['list', 'of', 'objects']                                                      | <ul><li>Объявление списка с произвольными типами объектов</li><li>Обращение к элементу из списка</li></ul><p><br></p> | <p>Объявление списка</p><ul><li>Пустой список</li><li>{{ \[] }}</li><li>Список чисел</li><li>{{ \[num1, num2, ...] }}</li><li>Список строк</li><li>{{ \['str1','str2', ...] }}{{ \["str1","str2", ...] }}</li></ul><p>Обращение к элементам спискаlist = {{ \[A, B, ...] }}{{ list\[0] }} = A{{ list\[1] }} = B...</p>                     | <ul><li>{{ \[1, 2, 3] }}</li><li>Результат: \[1, 2, 3].</li><li>{{ \['one', 'two'] }}</li><li>Результат: \['one', 'two'].</li><li>{{ \['one', 'two'] }}\[0]</li><li>Результат: one.</li></ul>                                                                                                                                                                 |
| Словари         | {'dict': 'of', 'key': 'and', 'value': 'pairs'}                                  | <ul><li>Объявление словаря</li><li>Обращение к элементу из словаря</li></ul>                                          | Объявление словаря{{ { key1:val1, key2:val2, ... } }}Обращение к элементам словаряdict = {{ { key1:val1, key2:val2, ... } }}{{ dict\[key1] }} = val1{{ dict\[key2] }} = val2...                                                                                                                                                            | <ul><li>{{ {1:'A', 2:'B', 3:'C'} }}</li><li>Результат: {1: 'A', 2: 'B', 3: 'C'}.</li><li>{{ {1:'A', 2:'B', 3:'C'}\[1] }}</li><li>Результат: A.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'} }}</li><li>Результат: {'one': 'A', 'two': 'B', 'three': 'C'}.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}\['three'] }}</li><li>Результат: C.</li></ul> |
| Массивы         | {{ \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] }} | <ul><li>Объявление массива данных</li><li>Обращение к элементу из массива</li></ul>                                   | Объявление массива{{ \[{'id': id1, 'value': val1 }, {'id': id2, 'value': val2 }, ...] }}Обращение к элементам массиваarray = {{ \[{'id': id1, 'value': val1 }, {'id': id2, 'value': val2 }, ...] }}{{ array\[0] }} = {'id': id1, 'value': val1 }...                                                                                        | <ul><li>{{ \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] }}</li><li>Результат: \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}].</li><li>{{ \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] \[0] }}</li><li>Результат: {'id': 3, 'name': 'O'}.</li></ul>                       |
| Булевы значения | <ul><li>true</li><li>false</li></ul>                                            | Выражения и булевы переменные                                                                                         | <ul><li>{{ true }}</li><li>{{ false }}</li></ul>                                                                                                                                                                                                                                                                                           | <ul><li>{{ А == true }}</li><li>Результат: True, если булева переменная A истинна.</li><li>{{ (A == B) == true }}</li><li>Результат: True, если выражение (A == B) истинно.</li></ul>                                                                                                                                                                         |

| Оператор                                                            | Обозначение | Область применения                                                                                                                                                                                                    | Как использовать                                                                                                                                             | Пример                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Сложение                                                            | +           | <ul><li>Сложение целых и вещественных чисел</li><li>Конкатенация строк</li><li>Объединение элементов массивов в один массив</li></ul>                                                                                 | <ul><li>{{ num1 + num2 + ... }}</li><li>{{ 'str1' + 'str2' + ... }}</li><li>{{ "str1" + "str2" + ... }}</li><li>{{ mas1 + mas2 + ... }}</li></ul><p><br></p> | <ul><li>{{ 1 + 2 + 3 }}</li><li>Результат: 6.</li><li>{{ 'a' + 'b' + 'c' }}</li><li>Результат: abc.</li><li>{{ 0.5 + 1.5 }}</li><li>Результат: 2.0.</li><li>{{ \[0,1,2] + \[3,4,5] }}</li><li>Результат: \[0, 1, 2, 3, 4, 5].</li></ul> |
| Вычитание                                                           | -           | Вычитание целых и вещественных чисел                                                                                                                                                                                  | {{ num1 - num2 - num3 - ... }}                                                                                                                               | <ul><li>{{ 4 - 2 - 1 }}</li><li>Результат: 1.</li><li>{{ 0.5 - 1.5 }}</li><li>Результат: -1.0.</li></ul>                                                                                                                                |
| Деление                                                             | /           | Деление целых и вещественных чисел                                                                                                                                                                                    | {{ num1 / num2 / num3 / ... }}                                                                                                                               | <ul><li>{{ 1 / 2 }}</li><li>Результат: 0.5.</li><li>{{ -1.5 / 0.5 }}</li><li>Результат: -3.0.</li><li>{{ 6 / 3 / 2 }}</li><li>Результат: 1.0.</li></ul>                                                                                 |
| Деление, при котором будет возвращена только целая часть результата | //          | Деление целых и вещественных чиселОграничения:Оператор //  возвращает целое число только при делении целых чисел. Если одним из операндов является вещественное число, то результатом также будет вещественное число. | {{ num1 // num2 // num3 // ... }}                                                                                                                            | <ul><li>{{ 6 // 3 // 2 }}</li><li>Результат: 1.</li><li>{{ 1.5 // 0.5 }}</li><li>Результат: 3.0.</li></ul>                                                                                                                              |
| Вычисление остатка от деления                                       | %           | Вычисление остатка от деления целых и вещественных чисел                                                                                                                                                              | {{ num1 % num2 }}                                                                                                                                            | <ul><li>{{ 6 % 4 }}</li><li>Результат: 2.</li><li>{{ 1.5 % 0.5 }}</li><li>Результат: 0.0.</li></ul>                                                                                                                                     |
| Умножение                                                           | \*          | Умножение целых и вещественных чисел                                                                                                                                                                                  | {{ num1 \* num2 \* num3 \* ... }}                                                                                                                            | <ul><li>{{ -1.5 \* -0.5 }}</li><li>Результат: 0.75.</li><li>{{ -2 \* 3 \* 4 }}</li><li>Результат: -24.</li></ul>                                                                                                                        |

Ограничения:

* Максимальное число (по модулю), которое можно использовать в арифметических операциях — 4294967296 . Если использовать большие числа, то будет ошибка (в memory в переменную сохранится False, например).
* Если складывать строки / массивы, то максимально допустимая длина строки / массива — 1000 . При попытке сложения/конкатенации строк/массивов, дающих результат длиннее 1000 символов, в Контекстная переменная error записывается значение “Addition of objects with length greater than 1000 is not allowed”.
* Для конкатенации строк/массивов, дающих результат длиннее 1000 символов, можно использовать запись {{ string\_1 }}{{ string\_2 }}.

| Оператор                                               | Обозначение | Область применения                      | Как использовать | Пример                                                                                                                                                                                                                                                             |
| ------------------------------------------------------ | ----------- | --------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Проверка равенства                                     | ==          | Любые контекстные переменные и значения | {{ A == B }}     | <ul><li>{{ A == B }}</li><li>Результат: True, если переменная A равна переменной B.</li><li>{{ A == 1 }}</li><li>Результат: True, если переменная A равна 1.</li><li>{{ A == 'один' }}</li><li>Результат: True, если переменная A равна 'один'.</li></ul>          |
| Проверка неравенства                                   | !=          | Любые контекстные переменные и значения | {{ A != B }}     | <ul><li>{{ A != B }}</li><li>Результат: True, если переменная A не равна переменной B.</li><li>{{ A != 1 }}</li><li>Результат: True, если переменная A не равна 1.</li><li>{{ A != 'один' }}</li><li>Результат: True, если переменная A не равна 'один'.</li></ul> |
| Проверка, что первый операнд больше второго            | >           | Числовые переменные и числа             | {{ A > B }}      | <ul><li>{{ A > B }}</li><li>Результат: True, если переменная A больше переменной B.</li><li>{{ A > 1 }}</li><li>Результат: True, если переменная A больше 1.</li></ul>                                                                                             |
| Проверка, что первый операнд больше либо равен второго | >=          | Числовые переменные и числа             | {{ A >= B }}     | <ul><li>{{ A >= B }}</li><li>Результат: True, если переменная A больше или равна переменной B.</li><li>{{ A >= 1 }}</li><li>Результат: True, если переменная A больше или равна 1.</li></ul>                                                                       |
| Проверка, что первый операнд меньше второго            | <           | Числовые переменные и числа             | {{ A < B }}      | <ul><li>{{ A < B }}</li><li>Результат: True, если переменная A меньше переменной B.</li><li>{{ A < 1 }}</li><li>Результат: True, если переменная A меньше 1.</li></ul>                                                                                             |
| Проверка, что первый операнд меньше либо равен второго | <=          | Числовые переменные и числа             | {{ A <= B }}     | <ul><li>{{ A <= B }}</li><li>Результат: True, если переменная A меньше или равна переменной B.</li><li>{{ A <= 1 }}</li><li>Результат: True, если переменная A меньше или равна 1.</li></ul>                                                                       |

| Оператор                         | Обозначение | Область применения            | Как использовать | Пример                                                                                                                                                                    |
| -------------------------------- | ----------- | ----------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| “И”                              | and         | Выражения и булевы переменные | {{ A and B }}    | <ul><li>{{ A and B }}</li><li>Результат: True, если если обе булевы переменные A и B истинны.</li></ul>                                                                   |
| "ИЛИ”                            | or          | Выражения и булевы переменные | {{ A or B }}     | <ul><li>{{ A or B }}</li><li>Результат: True, если если одна из булевых переменных A и B истинны.</li></ul>                                                               |
| "НЕ”                             | not         | Выражения и булевы переменные | {{ not A }}      | <ul><li>{{ not A }}</li><li>Результат: True, если если булева переменная A ложна.</li><li>{{ not A == 1 }}</li><li>Результат: False, если переменная A равна 1.</li></ul> |
| Скобки для группировки выражения | (expr)      | Выражения и булевы переменные | {{ (A) }}        | <ul><li>{{ (A > 0) and (A < 10) }}</li><li>Результат: True, если переменная A больше 0 и меньше 10.</li></ul>                                                             |

| Оператор                                         | Обозначение | Область применения                 | Как использовать                                                                                                                                                                                                                                   | Пример                                                                                                                                                                                                                                                       |
| ------------------------------------------------ | ----------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Поиск первого операнда во втором                 | in          | Контекстные переменные и выражения | <ul><li>Строка</li><li>{{ 's' in 'str' }}</li><li>Список чисел</li><li>{{ num in \[num1,num2,...] }}</li><li>Список строк</li><li>{{ 'str' in \['str1','str2',...] }}</li><li>Словарь</li><li>{{ key in { key1:val1, key2:val2, ... } }}</li></ul> | <ul><li>{{ 'A' in 'ABC' }}</li><li>Результат: True.</li><li>{{ 1 in \[1,2,3] }}</li><li>Результат: True.</li><li>{{ 'ABC' in \['ABC','DEF','GHI'] }}</li><li>Результат: True.</li><li>{{ 1 in {1: 'A', 2: 'B', 3: 'C'} }}</li><li>Результат: True.</li></ul> |
| Проверка операнда на свойство                    | is          | Тесты                              | {{ A is B }}                                                                                                                                                                                                                                       | Описано в таблице: Проверки значений переменных                                                                                                                                                                                                              |
| Применяет фильтр по отношению к операнду         | \|          | Фильтры                            | {{ A\|B }}                                                                                                                                                                                                                                         | Описано в таблице: Фильтры синтаксиса                                                                                                                                                                                                                        |
| Приведение операндов к строкам и их конкатенация | \~          | Контекстные переменные и строки    | <ul><li>{{ "string" \~ var }}</li><li>{{ var \~ "string" }}</li></ul>                                                                                                                                                                              | {{ "Hello " \~ name \~ "!" }}Результат: Hello John! (если переменная name содержит значение John).                                                                                                                                                           |
| Получение артибута объекта                       | . / \[]     | Любые контекстные переменные       | <ul><li>{{ A.B }}</li><li>{{ A\['B'] }}</li></ul>                                                                                                                                                                                                  | <ul><li>{{ \['A','B','C'].0 }}</li><li>Результат: A.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}\['two'] }}</li><li>Результат: B.</li></ul>                                                                                                            |

### Проверки значений переменных

| Тест                                                                                                         | Обозначение | Как использовать                                                                                                                                                                                                                     | Пример                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------------------------------------------------------------------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Проверка, что переменная существует в контексте                                                              | defined     | {{ A is defined }}                                                                                                                                                                                                                   | <ul><li>{{ A is defined }}, A существует</li><li>Результат: True.</li><li>{{ A is defined }}, A не существует</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                |
| Проверка, что переменная не существует в контексте                                                           | undefined   | {{ A is undefined }}                                                                                                                                                                                                                 | <ul><li>{{ A is undefined }}, A существует</li><li>Результат: False.</li><li>{{ A is undefined }}, A не существует</li><li>Результат: True.</li></ul>                                                                                                                                                                                                            |
| Проверка на соответствие регулярному выражению                                                               | match       | {{ A is match ... }}                                                                                                                                                                                                                 | <p>{{ A is match("\[regular\_expression]") }}<br>Результат:</p><ul><li>True, если A соответствует регулярному выражению;</li><li>False, если A НЕ соответствует регулярному выражению;</li><li>False, если A имеет не строковый формат;</li><li>False, если регулярное выражение прописано некорректно</li></ul><p>Важно: проверка чувствительна к регистру.</p> |
| Проверка, что объект является числом                                                                         | number      | {{ A is number }}                                                                                                                                                                                                                    | <ul><li>{{ 5 is number }}</li><li>Результат: True.</li><li>{{ 'five' is number }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                            |
| Проверка, что объект является четным числом                                                                  | even        | {{ A is even }}                                                                                                                                                                                                                      | <ul><li>{{ 22 is even }}</li><li>Результат: True.</li><li>{{ 11 is even }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                                   |
| Проверка, что объект является нечетным числом                                                                | odd         | {{ A is odd }}                                                                                                                                                                                                                       | <ul><li>{{ 46 is odd }}</li><li>Результат: False.</li><li>{{ 15 is odd }}</li><li>Результат: True.</li></ul>                                                                                                                                                                                                                                                     |
| Проверка, что объект является целым числом                                                                   | integer     | {{ A is integer }}                                                                                                                                                                                                                   | <ul><li>{{ 1012 is integer }}</li><li>Результат: True.</li><li>{{ 10.12 is integer }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                        |
| Проверка, что объект является вещественным числом                                                            | float       | {{ A is float }}                                                                                                                                                                                                                     | <ul><li>{{ 3.55 is float }}</li><li>Результат: True.</li><li>{{ 35 is float }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                               |
| Проверка, что объект делится нацело на число                                                                 | divisibleby | <p>{{ A is divisibleby(B) }}Важно:</p><ul><li>Если A = True, а B = 1, то вернется True, т.к True это 1, а 1 делится на 1.</li><li>Если A = False, то вернется True, т.к False это 0, а 0 делится на любое число (кроме 0).</li></ul> | <ul><li>{{ 4 is divisibleby(2) }}</li><li>Результат: True.</li><li>{{ 6 is divisibleby(5) }}</li><li>Результат: False.</li><li>{{ 5 is divisibleby(0) }}</li><li>Результат: False.</li><li>{{ true is divisibleby(1) }}</li><li>Результат: True.</li><li>{{ false is divisibleby(10) }}</li><li>Результат: True.</li></ul>                                       |
| Проверка, что объект является строкой                                                                        | string      | {{ A is string }}                                                                                                                                                                                                                    | <ul><li>{{ 'one' is string }}</li><li>Результат: True.</li><li>{{ 1 is string }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                             |
| Проверка, что строка находится в нижнем регистре                                                             | lower       | {{ A is lower }}                                                                                                                                                                                                                     | <ul><li>{{ 'hello' is lower }}</li><li>Результат: True.</li><li>{{ 'Hello' is lower }}</li><li>Результат: False.</li><li>{{ 'HELLO' is lower }}</li><li>Результат: False.</li></ul>                                                                                                                                                                              |
| Проверка, что строка находится в верхнем регистре                                                            | upper       | {{ A is upper }}                                                                                                                                                                                                                     | <ul><li>{{ 'BYE' is upper }}</li><li>Результат: True.</li><li>{{ 'Bye' is upper }}</li><li>Результат: False.</li><li>{{ 'bye' is upper }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                    |
| Проверка, что объект является словарем                                                                       | mapping     | {{ A is mapping }}                                                                                                                                                                                                                   | <ul><li>{{ {1:'A', 2:'B', 3:'C'} is mapping }}</li><li>Результат: True.</li><li>{{ \[1, 2, 3] is mapping }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                  |
| Проверка, что объект является последовательностью (строкой, списком или словарем)                            | sequence    | {{ A is sequence }}                                                                                                                                                                                                                  | <ul><li>{{ '12345' is sequence }}</li><li>Результат: True.</li><li>{{ \[1, 2, 3] is sequence }}</li><li>Результат: True.</li><li>{{ {1:'A', 2:'B', 3:'C'} is sequence }}</li><li>Результат: True.</li><li>{{ 12345 is sequence }}</li><li>Результат: False.</li></ul>                                                                                            |
| Проверка, что объект является булевым                                                                        | boolean     | {{ A is boolean }}                                                                                                                                                                                                                   | <ul><li>{{ A is boolean }}, A = true</li><li>Результат: True.</li><li>{{ A is boolean }}, A = 4</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                              |
| Проверка, что объект является истинным                                                                       | true        | {{ A is true }}                                                                                                                                                                                                                      | <ul><li>{{ A is true }}, A = true</li><li>Результат: True.</li><li>{{ A is true }}, A = 1</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                    |
| Проверка, что объект является ложным                                                                         | false       | {{ A is false }}                                                                                                                                                                                                                     | <ul><li>{{ A is false }}, A = false</li><li>Результат: True.</li><li>{{ A is false }}, A = 2</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                 |
| Проверка, что у объекта отсутствует значение (значение None или Null (преобразуется при парсинге ER в None)) | none        | {{ A is none }}                                                                                                                                                                                                                      | <ul><li>{{ A is none }}, A = none</li><li>Результат: True.</li><li>{{ A is none }}, A = ''</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                   |
| Проверка равенства (эквивалентно оператору ==)                                                               | eq          | {{ A is eq B }}                                                                                                                                                                                                                      | <ul><li>{{ 123 is eq 123 }}</li><li>Результат: True.</li><li>{{ 'abc' is eq 'ABC' }}</li><li>Результат: False.</li><li>{{ 456 is eq '456' }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                 |
| Проверка неравенства (эквивалентно оператору !=)                                                             | ne          | {{ A is ne B }}                                                                                                                                                                                                                      | <ul><li>{{ 123 is ne 124 }}</li><li>Результат: True.</li><li>{{ 'D' is ne 'D' }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                             |
| Проверка, что первый операнд больше второго (эквивалентно оператору >)                                       | gt          | {{ A is gt B }}                                                                                                                                                                                                                      | <ul><li>{{ 5 is gt 3 }}</li><li>Результат: True.</li><li>{{ (-1.12) is gt 1.13 }}</li><li>Результат: False.</li><li>{{ '5a' is gt '33' }}</li><li>Результат: True.</li><li>{{ '222' is gt '33' }}</li><li>Результат: False.</li></ul>                                                                                                                            |
| Проверка, что первый операнд больше либо равен второго (эквивалентно оператору >=)                           | ge          | {{ A is ge B }}                                                                                                                                                                                                                      | <ul><li>{{ 12.12 is ge 12.1199 }}</li><li>Результат: True.</li><li>{{ 15 is ge 15 }}</li><li>Результат: True.</li><li>{{ 0 is ge (-15) }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                    |
| Проверка, что первый операнд меньше второго (эквивалентно оператору <)                                       | lt          | {{ A is lt B }}                                                                                                                                                                                                                      | <ul><li>{{ 0.001 is lt 1 }}</li><li>Результат: True.</li><li>{{ (-1) is lt (-1.5) }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                         |
| Проверка, что первый операнд меньше либо равен второго (эквивалентно оператору <=)                           | le          | {{ A is le B }}                                                                                                                                                                                                                      | <ul><li>{{ 21 is le 22 }}</li><li>Результат: True.</li><li>{{ (-1.11) is le (-1.11) }}</li><li>Результат: True.</li><li>{{ (1) is le (-12) }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                |
| Поиск первого операнда во втором                                                                             | in          | {{ A in B }}                                                                                                                                                                                                                         | Описано в таблице: Поиск первого операнда во втором                                                                                                                                                                                                                                                                                                              |

### Фильтры синтаксиса

<table><thead><tr><th>Фильтр</th><th>Обозначение</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Добавление дефолтного значения</td><td>default</td><td><ul><li>{{ A|default(B) }}</li><li>Значение B будет использоваться только в случае, если переменной A нет в контексте.</li><li>{{ A|default(B,true) }}</li><li>Значение B будет использоваться в случаях, если переменной A нет в контексте или если значение переменной A приводится к False (0, пустая строка, пустой массив, пустой список).</li></ul></td><td><ul><li>{{ A|default('A is not defined') }}, A = 1</li><li>Результат: 1.</li><li>{{ A|default('A is not defined') }}, A не существует</li><li>Результат: A is not defined.</li><li>{{ A|default('A is empty', true) }}, A = ''</li><li>Результат: A is empty.</li><li>{{ A|default('A is not defined', true) }},</li><li>A не существуетРезультат: A is not defined.</li></ul></td></tr><tr><td>Преобразование в целое число</td><td>int</td><td>{{ A|int }}</td><td><ul><li>{{ 2.53|int }}</li><li>Результат: 2.</li><li>{{ '-15'|int }}</li><li>Результат: -15.</li><li>{{ '12abc'|int }}</li><li>Результат: 0.</li></ul></td></tr><tr><td>Преобразование в вещественное число</td><td>float</td><td>{{ A|float }}</td><td><ul><li>{{ 2|float }}</li><li>Результат: 2.0.</li><li>{{ '-122'|float }}</li><li>Результат: -122.0.</li><li>{{ '1a'|float }}</li><li>Результат: 0.0.</li></ul></td></tr><tr><td>Возвращение абсолютного значения числа</td><td>abs</td><td>{{ A|abs }}Ограничения: работает только с целыми и вещественными числами.</td><td><ul><li>{{ -1|abs }}</li><li>Результат: 1.</li><li>{{ -0.1111|abs }}</li><li>Результат: 0.1111.</li></ul></td></tr><tr><td>Округление числа</td><td>round</td><td><ul><li>{{ A|round }}</li><li>Округление до целой части.</li><li>{{ A|round(B, C) }}</li><li>B - число знаков после запятой.C - тип округления:common - округление в большую или меньшую сторону.ceil - округление в большую сторону.floor - округление в меньшую сторону.</li></ul></td><td><ul><li>{{ 42.12345|round }}</li><li>Результат: 42.0.</li><li>{{ -1.538675|round(3,'common') }}</li><li>Результат: -1.539.</li><li>{{ 0.5712|round(2, 'ceil') }}</li><li>Результат: 0.58.</li><li>{{ 121.67354|round(3, 'floor') }}</li><li>Результат: 121.673.</li><li>{{ 0.11111|round|int }}</li><li>Результат: 0.</li></ul></td></tr><tr><td>Преобразование в строку</td><td>string</td><td>{{ A|string }}</td><td><ul><li>{{ 12345|string }}</li><li>Результат: 12345.</li><li>{{ [1,2,3,4,5]|string }}</li><li>Результат: [1, 2, 3, 4, 5] (весь список является строкой).</li><li>{{ {1: 'A', 2: 'B', 3: 'C'}|string }}</li><li>Результат: {1: 'A', 2: 'B', 3: 'C'} (весь словарь является строкой).</li></ul></td></tr><tr><td>Преобразование в список</td><td>list</td><td>{{ A|list }}</td><td><ul><li>{{ 'abcdefg'|list }}</li><li>Результат: ['a', 'b', 'c', 'd', 'e', 'f', 'g'].</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|list }}</li><li>Результат: ['one', 'two', 'three'].</li><li>{{ 12345|list }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Преобразование в нижний регистр</td><td>lower</td><td>{{ A|lower }}</td><td><ul><li>{{ 'AbcDefg'|lower }}</li><li>Результат: abcdefg.</li><li>{{ ['A','B','C']|lower }}</li><li>Результат: ['a', 'b', 'c'].</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|lower }}</li><li>Результат: {'one': 'a', 'two': 'b', 'three': 'c'}.</li></ul></td></tr><tr><td>Преобразование в верхний регистр</td><td>upper</td><td>{{ A|upper }}</td><td><ul><li>{{ 'AbcDefg'|upper }}</li><li>Результат: ABCDEFG.</li><li>{{ ['a','b','c']|upper }}</li><li>Результат: ['A', 'B', 'C'].</li><li>{{ {'one': 'a', 'two': 'b', 'three': 'c'}|upper }}</li><li>Результат: {'ONE': 'A', 'TWO': 'B', 'THREE': 'C'}.</li></ul></td></tr><tr><td>Приведение первой буквы в строке к верхнему регистру</td><td>capitalize</td><td>{{ A|capitalize }}Ограничения: работает только со строками.</td><td><ul><li>{{ 'abc'|capitalize }}</li><li>Результат: Abc.</li></ul></td></tr><tr><td>Преобразование в заглавный регистр (т.е. слова будут начинаться с прописных букв, все остальные символы будут строчными)</td><td>title</td><td>{{ A|title }}Важно: элементы списка и словаря приводятся к нижнему регистру.</td><td><ul><li>{{ 'hello'|title }}</li><li>Результат: Hello.</li><li>{{ 'hELLO'|title }}</li><li>Результат: Hello.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|title }}</li><li>Результат: {'one': 'a', 'two': 'b', 'three': 'c'}.</li></ul></td></tr><tr><td>Первый элемент последовательности (строки, списка или словаря)</td><td>first</td><td>{{ A|first }}</td><td><ul><li>{{ '12345'|first }}</li><li>Результат: 1.</li><li>{{ [1, 2, 3]|first }}</li><li>Результат: 1.</li><li>{{ {1:'A', 2:'B', 3:'C'}|first }}</li><li>Результат: 1.</li><li>{{ 12345|first }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Последний элемент последовательности (строки, списка или словаря)</td><td>last</td><td>{{ A|last }}</td><td><ul><li>{{ '12345'|last }}</li><li>Результат: 5.</li><li>{{ [1, 2, 3]|last }}</li><li>Результат: 3.</li><li>{{ {1:'A', 2:'B', 3:'C'}|last }}</li><li>Результат: 3.</li><li>{{ 12345|last }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Число элементов в последовательности (строке, списке или словаре)</td><td>length</td><td>{{ A|length }}</td><td><ul><li>{{ 'abcdefg'|length }}</li><li>Результат: 7.</li><li>{{ [1, 2, 3]|length }}</li><li>Результат: 3.</li><li>{{ {1:'A'}|length }}</li><li>Результат: 1.</li><li>{{ 111|length }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Сумма элементов последовательности</td><td>sum</td><td>{{ A|sum }}Важно: если последовательность пустая, то возвращается 0.</td><td><ul><li>{{ [1,2,3,4,5]|sum }}</li><li>Результат: 15.</li><li>{{ {1: 'A', 2: 'B', 3: 'C'}|sum }}</li><li>Результат: 6.</li><li>{{ ''|sum }}</li><li>Результат: 0.</li></ul></td></tr><tr><td>Получение наименьшего значения элемента последовательности</td><td>min</td><td>{{ A|min }}</td><td><ul><li>{{ [1, 0.001, -1]|min }}</li><li>Результат: -1.</li><li>{{ ['1', '0.001', '-1']|min }}</li><li>Результат: -1.</li><li>{{ ['b', 'f', 'a']|min }}</li><li>Результат: a.</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|min }}</li><li>Результат: 1.</li></ul></td></tr><tr><td>Получение наибольшего значения элемента последовательности</td><td>max</td><td>{{ A|max }}</td><td><ul><li>{{ [1, 0.001, -1]|max }}</li><li>Результат: 1.</li><li>{{ ['1', '0.001', '-1']|max }}</li><li>Результат: 1.</li><li>{{ ['b', 'f', 'a']|max }}</li><li>Результат: f.</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|max }}</li><li>Результат: 3.</li></ul></td></tr><tr><td>Получение случайного элемента</td><td>random</td><td>{{ A|random }}Ограничения: работает только со списками и массивами.</td><td><ul><li>{{ [-22, 4.110263, 353, 124]|random }}</li><li>Результат: 4.110263.</li><li>{{ ['-22', '4.110263', '353', '124']|random }}</li><li>Результат: -22.</li><li>{{ ['apple', 'orange', 'banana']|random }}</li><li>Результат: banana.</li></ul></td></tr><tr><td>Замена элемента последовательности</td><td>replace</td><td>{{ A|replace }}</td><td><ul><li>{{ "Hello World"|replace("Hello", "Goodbye") }}</li><li>Результат: Goodbye World.</li><li>{{ ['A','B','C']|replace('A', 'D') }}</li><li>Результат: ['D', 'B', 'C'].</li></ul></td></tr><tr><td>Переворачивание последовательности</td><td>reverse</td><td>{{ A|reverse }}Важно: чтобы перевернуть список или словарь, нужно добавить |list для преобразования результата в список, иначе переменная будет пустой.</td><td><ul><li>{{ 'abcdefg'|reverse }}</li><li>Результат: gfedcba.</li><li>{{ '12345'|reverse }}</li><li>Результат: 54321.</li><li>{{ ['a', 'b', 'c']|reverse|list }}</li><li>Результат: ['c', 'b', 'a'].</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|reverse|list }}</li><li>Результат: ['3', '2', '1'].</li></ul></td></tr><tr><td>Добавление разделителя элементов последовательности (строки, списка или словаря)</td><td>join</td><td><ul><li>{{ A|join }}</li><li>{{ A|join(B) }}</li></ul></td><td><ul><li>{{ '123'|join(',') }}</li><li>Результат: (1, 2, 3).</li><li>{{ [1, 2, 3]|join }}</li><li>Результат: 123.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|join('!') }}</li><li>Результат: one!two!three.</li><li>{{ {1:'A', 2:'B', 3:'C'}.values()|join(", ") }}</li><li>Результат: A, B, C.</li><li>{{ {1:'A', 2:'B', 3:'C'}.keys()|join("!")|list }}</li><li>Результат: ['1', '!', '2', '!', '3'].</li></ul></td></tr><tr><td>Преобразование последовательности в уникальный список</td><td>unique</td><td>{{ A|unique|list }}Ограничения: работает только с добавлением |list.</td><td><ul><li>{{ 'abcab'|unique|list }}</li><li>Результат: gfedcba.</li><li>{{ '12345'|reverse }}</li><li>Результат: 54321.</li><li>{{ ['a', 'b', 'c']|reverse|list }}</li><li>Результат: ['c', 'b', 'a'].</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|reverse|list }}</li><li>Результат: ['3', '2', '1'].</li></ul></td></tr><tr><td>Сортировка последовательности</td><td>sort</td><td><ul><li>{{ A|sort }}</li><li>{{ A|sort(r, c, a) }}</li></ul><p>r(reverse) - сортировка по убыванию, а не по возрастанию.c(case_sensitive) - сортировка верхнего и нижнего регистров отдельно.a(attribute) - значение или ключ для сортировки.</p></td><td><ul><li>{{ [1,4,3,2,5]|sort }}</li><li>Результат: [1, 2, 3, 4, 5].</li><li>{{ ['b','a','c']|sort(reverse=true) }}</li><li>Результат: ['c', 'b', 'a'].</li><li>{{ [{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}]|sort(attribute='name') }}</li><li>Результат: [{'id': 1, 'name': 'E'}, {'id': 3, 'name': 'O'}, {'id': 2, 'name': 'S'}].</li><li>{{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}.values()|sort }}</li><li>Результат: ['a', 'b', 'c', 'd'].</li><li>{{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}.keys()|sort }}</li><li>Результат: [1, 2, 3, 4].</li></ul></td></tr><tr><td>Сортировка словаря по ключу или значению</td><td>dictsort</td><td><ul><li>{{ A|dictsort }}</li><li>{{ A|dictsort(by='key' }}</li><li>{{ A|dictsort(by='value' }}</li></ul><p>Важно: словарь по умолчанию превращается в строку.</p></td><td><ul><li>{% for key, value in {"c": 1, "a": 4, "b": 2, "d": 3}|dictsort %} {{ key }}: {{ value }} {% endfor %}</li><li>Результат: aaa: 4 b: 2 c: 1 d: 3.</li><li>{% for key, value in {"c": 1, "a": 4, "b": 2, "d": 3}|dictsort(by="key") %} {{ key }}: {{ value }} {% endfor %}</li><li>Результат: a: 4 b: 2 c: 1 d: 3.</li><li>{{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}|dictsort(by='value')|list }}</li><li>Результат: [(2, 'a'), (3, 'b'), (4, 'c'), (1, 'd')].</li></ul><p><br></p></td></tr><tr><td>Фильтрация по атрибуту</td><td>map</td><td>{{ A|map(attribute='B')|map(attribute='C'|...|list }}Важно: если объект является массивом, то результат необходимо преобразовать в список.</td><td><ul><li>{{ [{'name': 'Anna', 'number': '123'}, {'name': 'Olga', 'number': '456'}, {'name': 'Evgeniya', 'number': '789'}]| map(attribute='name')|list }}</li><li>Результат: ['Anna', 'Olga', 'Evgeniya'].</li></ul></td></tr><tr><td>Группировка по числу элементов в цикле</td><td>batch</td><td><ul><li>{{ A|batch(l) }}</li><li>{{ A|batch(l, f) }}</li></ul><p>l(linecount) - число групп, на которые будет разбит объект.f(fill_with) - значение, которое используется для заполнения отсутсвующих элементов.</p></td><td><ul><li>{% for row in ['A','B','C']|batch(5, 'D') %}{{ row }}{% endfor %}</li><li>Результат: ['A', 'B', 'C', 'D', 'D'].</li><li>{% for row in [1, 2, 3, 4]|batch(2) %}</li><li>{% for i in row %}{{ i }}{% endfor %}{% endfor %}Результат:1234.</li></ul></td></tr><tr><td>Преобразование в список списков</td><td>slice</td><td><ul><li>{{ A|slice(s) }}</li><li>{{ A|slice(s, f) }}</li></ul><p>s(slices) - число списков, на которые будет разбит объект.f(fill_with) - значение, которое используется для заполнения отсутсвующих элементов.</p></td><td><ul><li>{{ [1, 2, 3, 4, 5]|slice(2)|list }}</li><li>Результат: [[1, 2, 3], [4, 5]].</li><li>{{ 'abc'|slice(5, 'd')|list }}</li><li>Результат: [['a'], ['b'], ['c'], ['d'], ['d']].</li></ul></td></tr><tr><td>Группировка по атрибуту</td><td>groupby</td><td><ul><li>{{ A|groupby(a) }}</li><li>{{ A|groupby(a, d) }}</li></ul><p>a(attribute) - атрибут.d(default) - значение по умолчанию, использующееся, если объект в списке не имеет данного атрибута.</p></td><td><ul><li>items = [ {"name": "james",  "type": "green"}, {"name": "john", "type": "blue"}, {"name": "jim", "type": "blue"}, {"name": "jessie", "type": "green"} ]</li></ul><pre><code>{% for type, items in items|groupby('type') %}{{ type }}:{% for item in items %}{{ item.name }} {% endfor %}{% endfor %}
</code></pre><p>Результат: blue: john jim green: james jessie.</p></td></tr><tr><td>Удаление элементов последовательности, которые не соответствуют тесту</td><td>select</td><td>{{ A|select(B,C)|list }}B - тест из таблицы Проверки значений переменных.C - аргумент, который передается в тест B.</td><td><ul><li>{{ [1, 2, 3, 4, 5]|select('odd')|list }}</li><li>Результат: [1, 3, 5] (нечетные числа).</li><li>{{ [1, 2, 3, 4, 5]|select('gt', 3)|list }}</li><li>Результат: [4, 5] (числа, которые больше 3).</li></ul></td></tr><tr><td>Удаление элементов последовательности, которые не соответствуют тесту по атрибуту</td><td>selectattr</td><td>{{ A|selectattr(B,C,D)|list }}B - атрибут, который необходимо достать из последовательности.C - тест из таблицы Проверки значений переменных.D - аргумент, который передается в тест С.</td><td><ul><li>users = [ {"name": "james",  "email": "james@james.com", "password": "123"}, {"name": "john", "email": "john@john.com"}, {"name": "jim", "email": "jim@jim.com"}, {"name": "jessie", "email": "jessie@jessie.com", "password": "123"} ] .</li><li>{{ users|selectattr('password','undefined')| map(attribute='email')|list }}{{ email }}Результат: ['john@john.com', 'jim@jim.com'].</li><li>table = [['685697115', 'evpolyntseva', 'Новосибирск'], ['658795243', 'Iourigaha', 'Москва'], ['683128920', 'jarondara', 'Казань'], ['630685929', 'blarar', 'Москва']] .</li><li>{{ table_all|selectattr(2, 'eq', "Москва")|map(attribute=1)|list }}Результат: ['Iourigaha', 'blarar'].</li></ul></td></tr><tr><td>Удаление элементов последовательности, которые соответствуют тесту</td><td>reject</td><td>{{ A|reject(B,C)|list }}B - тест из таблицы Проверки значений переменных .C - аргумент, который передается в тест B.</td><td><ul><li>{{ [1, 2, 3, 4, 5]|reject('odd')|list }}</li><li>Результат: [2, 4] (не нечетные числа).</li><li>{{ [1, 2, 3, 4, 5]|reject('gt', 3)|list }}</li><li>Результат: [1, 2, 3] (числа, которые не больше 3).</li></ul></td></tr><tr><td>Удаление элементов последовательности, которые соответствуют тесту по атрибуту</td><td>rejectattr</td><td>{{ A|rejectattr(B)|list }}B - атрибут, который необходимо достать из последовательности.C - тест из таблицы Проверки значений переменных .D - аргумент, который передается в тест С.</td><td><ul><li>table = [['685697115', 'evpolyntseva', 'Новосибирск'], ['658795243', 'Iourigaha', 'Москва'], ['683128920', 'jarondara', 'Казань'], ['630685929', 'blarar', 'Москва']] .</li><li>{{ table|selectattr(2, 'eq', "Москва")|map(attribute=1)|list }}Результат: ['evpolyntseva', 'jarondara'].</li></ul></td></tr><tr><td>Удаление символов в начале и конце строки</td><td>trim</td><td><ul><li>{{ A|trim }}</li><li>{{ A|trim(c) }}</li></ul><p>c(chars) - символ или строка, которые будут удалены. По умолчанию пробел.</p></td><td><ul><li>{{ ' a '|trim }}</li><li>Результат: a.</li><li>{{ 'bbbсbb'|trim('b') }}</li><li>Результат: c.</li></ul></td></tr><tr><td>Усечение строки</td><td>truncate</td><td><ul><li>{{ A|truncate(len) }}</li><li>{{ A|truncate(len,k,e,l) }}</li></ul><p>len(length) - длина урезанной строки. По умолчанию 255.k(killwords) - True или False. True указывается если нужно обрезать строку по длине, False если нужно отбросить последнее обрезаемое слово.e(end) - знак на месте усечения. По умолчанию многоточие.l(leeway) - предел превышения длины.</p></td><td><ul><li>{{ 'foo bar baz qux'|truncate(9) }}</li><li>Результат: foo... .</li><li>{{ 'foo bar baz qux'|truncate(9, True) }}</li><li>Результат: foo ba... .</li><li>{{ 'foo bar baz qux'|truncate(11, False, '', 0) }}</li><li>Результат: foo bar.</li></ul></td></tr><tr><td>Подсчет слов</td><td>wordcount</td><td>{{ A|wordcount }}</td><td><ul><li>{{ 'Hello World!'|wordcount }}</li><li>Результат: 2.</li><li>{{ ['a a a','b','c']|wordcount }}</li><li>Результат: 5.</li><li>{{ {'one': 'a', 'two': 'b b b', 'three': 'c'}|wordcount }}</li><li>Результат: 8.</li></ul></td></tr><tr><td>Форматирование числа в размер файла</td><td>filesizeformat</td><td>{{ A|filesizeformat }}</td><td><ul><li>{{ 100000 | filesizeformat }}</li><li>Результат: 100.0 kB.</li><li>{{ 25000000 | filesizeformat }}</li><li>Результат: 25.0 MB.</li></ul></td></tr><tr><td>Кодирование в URL</td><td>urlencode</td><td>{{ A|urlencode }}Важно: работает только со строками и словарями.</td><td><ul><li>{{ 'привет'|urlencode }}</li><li>Результат: %D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82.</li><li>{{ {"aaa": "привет", "bbb": 1}|urlencode }}</li><li>Результат: aaa=%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82&#x26;bbb=1.</li></ul></td></tr><tr><td>Преобразование строки в дату</td><td>string_to_time</td><td>{{ "2000-06-15 18:50:47" | string_to_time("%Y-%m-%d %H:%M:%S") }}<br>После string_to_time в скобках указывается необходимый формат даты. Подробнее: <a href="https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes">https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes</a></td><td>{{ "2000-06-15 18:50:47" | string_to_time("%Y-%m-%d %H:%M:%S") }}<br>Результат: 2000-06-15 18:50:47 (тип данных — дата)</td></tr><tr><td>Преобразование даты в строку</td><td>time_to_string</td><td>{{ "2000-06-15 18:50:47" | time_to_string("%Y-%m-%d %H:%M:%S") }}<br>После time_to_string в скобках указывается необходимый формат даты. Подробнее: <a href="https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes">https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes</a></td><td>{{ "2000-06-15 18:50:47" | time_to_string("%Y-%m-%d %H:%M:%S") }}<br>Результат: 2000-06-15 18:50:47 (тип данных — строка)</td></tr></tbody></table>

## Выражения с управляющими конструкциями

| Оператор                                             | Обозначение     | Область применения           | Как использовать                                                                                                                                                                                                         | Пример                                                                |
| ---------------------------------------------------- | --------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------- |
| Пройти циклом по каждому элементу последовательности | for, in, endfor | Любые контекстные переменные | {% for A in B %}{{ ... }}{% endfor %}Важно: цикл может быть максимум двойной вложенности.Внутри циклов можно использовать дополнительные переменные для проверки значений: <https://coda.io/d/\\_d\\_pM7PjYCmj#\\_tuYU1> | {% for number in \[1, 2, 3] %}{{ number }}{% endfor %}Результат: 123. |

<table><thead><tr><th>Переменная</th><th>Обозначение</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Номер итерации с начала цикла (1 проиндексирована)</td><td>loop.index</td><td>{{ loop.index }}</td><td><pre><code>{% for i in [{'name': 'Молоко', 'quantity': '1'}, {'name': 'Яблоки', 'quantity': '4'}, {'name': 'Печенье', 'quantity': '1'}] %}{{ loop.index }}{{ ') ' }}{{ i.name }} {{ i.quantity }} {% endfor %}
</code></pre><p>Результат:1) Молоко 12) Яблоки 43) Печенье 1</p></td></tr><tr><td>Номер итерации с начала цикла (0 проиндексирован)</td><td>loop.index0</td><td>{{ loop.index0 }}</td><td><pre><code>{% for i in ['A','B','C'] %}{{ loop.index0 }}{{ ': ' }}{{ i }}{% endfor %}
</code></pre><p>Результат:0: A1: B2: C.</p></td></tr><tr><td>Номер итерации с конца цикла (1 проиндексирована)</td><td>loop.revindex</td><td>{{ loop.revindex }}</td><td><p>dict = {{ {'one': 'A', 'two': 'B', 'three': 'C'} }}</p><pre><code>{% for i in dict %}{{ loop.revindex }}{{ ': ' }}{{ i }}{{ ' is ' }}{{ dict[i] }}{% endfor %}
</code></pre><p>Результат:3: one is A2: two is B1: three is C.</p></td></tr><tr><td>Номер итерации с конца цикла (0 проиндексирован)</td><td>loop.revindex0</td><td>{{ loop.revindex0 }}</td><td><pre><code>{% for i in ['apple','orange','cherry'] %}{{ loop.revindex0 }}{{ ' | ' }}{{ i }}{% endfor %}
</code></pre><p>Результат:2 | apple1 | orange0 | cherry.</p></td></tr><tr><td>Истина, если первая итерация</td><td>loop.first</td><td>{{ loop.first }}</td><td><pre><code>{% for i in ['a','b','c','d','e'] %}{% if loop.first == true %}{{ i }}{{ ' is first' }}{% endif %}{% endfor %}
</code></pre><p>Результат: a is first.</p></td></tr><tr><td>Истина, если последняя итерация</td><td>loop.last</td><td>{{ loop.last }}</td><td><pre><code>{% for i in ['a','b','c','d','e'] %}{% if loop.last == true %}{{ i }}{{ ' is last' }}{% endif %}{% endfor %}
</code></pre><p>Результат: e is last.</p></td></tr><tr><td>Количество элементов в последовательности</td><td>loop.length</td><td>{{ loop.length }}</td><td><pre><code>{% for i in ['a','b','c','d','e'] %}{% if loop.last == true %}{{ 'длина: '}}{{ loop.length }}{% endif %}{% endfor %}
</code></pre><p>Результат: длина: 5.</p></td></tr><tr><td>Циклическое перемещение внутри объекта</td><td>loop.cycle</td><td>{{ loop.cycle }}</td><td><p>dict = {{ {'one': 'A', 'two': 'B', 'three': 'C'} }}</p><pre><code>{% for i in dict %}{{ loop.cycle }}{{ dict[i] }}{% endfor %}
</code></pre><p>Результат: >A>B>C.</p></td></tr><tr><td>Глубина рекурсивного цикла (начиная с уровня 1)</td><td>loop.depth</td><td>{{ loop.depth }}</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.last == true %}{{ 'глубина: '}}{{ loop.depth }}{% endif %}{% endfor %}
</code></pre><p>Результат: глубина: 1.</p></td></tr><tr><td>Глубина рекурсивного цикла (начиная с уровня 0)</td><td>loop.depth0</td><td>{{ loop.depth0 }}</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.last == true %}{{ 'глубина: '}}{{ loop.depth0 }}{% endif %}{% endfor %}
</code></pre><p>Результат: глубина: 0.</p></td></tr><tr><td>Получение значения из предыдущей интерации цикла</td><td>loop.previtem</td><td>{{ loop.previtem }}Важно: элемент не определен, если итерация является первой.</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.first == false %}{{ 'предыдущий элемент: '}}{{ loop.previtem }}{% endif %}{% endfor %}
</code></pre><p>Результат:предыдущий элемент: 1предыдущий элемент: 2.</p></td></tr><tr><td>Получение значения из следующей интерации цикла</td><td>loop.nextitem</td><td>{{ loop.nextitem }}Важно: элемент не определен, если итерация является последней.</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.last == false %}{{ 'следующий элемент: '}}{{ loop.nextitem }}{% endif %}{% endfor %}
</code></pre><p>Результат:следующий элемент: 2следующий элемент: 3.</p></td></tr><tr><td>Проверка изменялось ли значение переменной</td><td>loop.changed(val)</td><td>{{ loop.changed(A) }}</td><td><p>mass = [{'k': 3, 'v': 2}, {'k': 2, 'v': 3}, {'k': 2, 'v': 2}]</p><pre><code>{% for row in mass %}{% if loop.changed(row.k) == true %}{{ row.k }}{% endif %}{% endfor %}
</code></pre><p>Результат:32.</p></td></tr></tbody></table>

<table><thead><tr><th>Оператор</th><th>Обозначение</th><th>Область применения</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Условные конструкции</td><td>if, elif, else, endif</td><td>Любые контекстные переменные</td><td>Для более больших условий, нежели if-выражения, например, для слота Text:{% if ... %}A{% else %}B{% endif %}Могут использоваться elif и else.</td><td><pre><code>{% if current_time > 18 %}Добрый вечер!{% else %}Добрый день!{% endif %}
</code></pre><p>Результат: ‘Добрый вечер!’, если переменная current_time содержит значение более 18.‘Добрый день!’, если переменная current_time содержит значение менее либо равное 18.<br></p></td></tr></tbody></table>

<br>

<table><thead><tr><th>Оператор</th><th>Обозначение</th><th>Область применения</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Применяет фильтр по отношению к блоку данных шаблона</td><td>filter, endfilter</td><td>Любые контекстные переменные</td><td>Аналогично выражениям с использованием фильтров, только для более больших условий{% filter &#x3C;фильтр> %}  TEXT{% endfilter %}Фильтры: https://coda.io/d/_d_pM7PjYCmj#_tuKuk</td><td><pre><code>{% filter upper %}    This text becomes uppercase{% endfilter %}
</code></pre><p>Результат: THIS TEXT BECOMES UPPERCASE.</p></td></tr></tbody></table>

<table><thead><tr><th>Оператор</th><th>Обозначение</th><th>Область применения</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Присваивает значение операнду</td><td>set</td><td>Любые контекстные переменные</td><td><ul><li>{% set A = B%}</li></ul></td><td><pre><code>{% set x = 'apples' if age is even else 'oranges' %}{{ x }}
</code></pre><p>Результат: ‘apples’, если переменная age содержит четное число.‘oranges’, если переменная age содержит нечетное число.</p></td></tr></tbody></table>

## Ошибки при рендеринге Шаблонов

При Обучение Агента в процессе Валидация сценария проверяется правильность используемых в Слотах Выражение и Выражение с управляющей конструкцией. При обнаружении ошибок появится предупреждение:\
![image.png](https://codahosted.io/docs/_pM7PjYCmj/blobs/bl-9pME_AbZcQ/96a98d3db218ff2fd1dae769e1d362417d9f2e398050a3ac40d467c0cc31ab5fbabc867a350469b4ab8a8762c38c6e0df0a473dcaa4affb86132b3e26784e47f0b0216f3199fdcabaa7421a2e19c076b359fc78ad6018f48eaaa3c341dfba727f0852535)

Формат текста предупреждения:

```
Invalid template syntax:Slot <id проблемного слота>. Error “<описание ошибки>” in expression “<проблемное выражение>”
```

Пример:

```
Invalid template syntax:Slot 8848840. Error “unexpected char '@' at 3” in expression “{{ @foo }}”
```

Расшифровка ошибки: в Слоте 8848840 обнаружена ошибка — лишний символ '@' с порядковым номером 3 в выражении {{ @foo }}.

> Важно: отсчет порядковых номеров символов в проблемном выражении начинается с 0.

<br>