Создаем CLI приложение на Python с Prompt Toolkit

from prompt_toolkit import prompt
 
user_input = prompt('Введите команду: ')
print(f'Вы ввели: {user_input}')

from prompt_toolkit import prompt
from prompt_toolkit.completion import WordCompleter
from prompt_toolkit.lexers import PygmentsLexer
from pygments.lexers.python import PythonLexer
 
python_completer = WordCompleter(['print', 'def', 'class', 'import', 'if', 'else', 'while', 'for', 'try', 'except'])
 
code = prompt('>>> ', lexer=PygmentsLexer(PythonLexer), completer=python_completer)

from pygments.lexers.sql import SqlLexer
from prompt_toolkit.lexers import PygmentsLexer
 
sql_input = prompt('SQL> ', lexer=PygmentsLexer(SqlLexer))

from rich.console import Console
from rich.table import Table
from prompt_toolkit import prompt
 
# Интерактивный ввод через Prompt Toolkit
query = prompt('Введите запрос: ')
 
# Красивый вывод результатов через Rich
console = Console()
table = Table(show_header=True)
table.add_column("ID")
table.add_column("Имя")
table.add_column("Значение")
 
# Представим, что это результат запроса
table.add_row("1", "Alpha", "100")
table.add_row("2", "Beta", "200")
 
console.print(table)

import asyncio
from prompt_toolkit import PromptSession
 
async def my_async_cli():
    session = PromptSession()
    while True:
        try:
            result = await session.prompt_async('> ')
            print(f'Вы ввели: {result}')
        except KeyboardInterrupt:
            break
 
asyncio.run(my_async_cli())

from prompt_toolkit import prompt
 
user_input = prompt('> ')
print(f'Вы ввели: {user_input}')

from prompt_toolkit import PromptSession
from prompt_toolkit.completion import WordCompleter
 
def main():
    # Создаём сессию - она сохраняет историю и настройки между вызовами
    session = PromptSession()
    
    # Определяем команды нашего приложения
    commands = ['help', 'status', 'load', 'save', 'exit']
    completer = WordCompleter(commands)
    
    # Основной цикл приложения
    while True:
        # Получаем ввод с автодополнением
        user_input = session.prompt('> ', completer=completer)
        
        # Обрабатываем ввод
        if user_input == 'exit':
            break
        elif user_input == 'help':
            print("Доступные команды: " + ", ".join(commands))
        else:
            print(f"Выполняется команда: {user_input}")
 
if __name__ == '__main__':
    main()

from prompt_toolkit import PromptSession
from prompt_toolkit.completion import WordCompleter
 
def handle_help(args):
    print("Доступные команды: help, status, load <filename>, save <filename>, exit")
 
def handle_load(args):
    if not args:
        print("Ошибка: необходимо указать имя файла")
        return
    print(f"Загружаем файл: {args[0]}")
 
def handle_save(args):
    if not args:
        print("Ошибка: необходимо указать имя файла")
        return
    print(f"Сохраняем в файл: {args[0]}")
 
def handle_status(args):
    print("Статус системы: всё работает отлично!")
 
def main():
    session = PromptSession()
    
    # Словарь команд и соответствующих обработчиков
    command_handlers = {
        'help': handle_help,
        'load': handle_load,
        'save': handle_save,
        'status': handle_status,
    }
    
    completer = WordCompleter(list(command_handlers.keys()) + ['exit'])
    
    while True:
        user_input = session.prompt('> ', completer=completer)
        
        # Разбиваем ввод на команду и аргументы
        parts = user_input.strip().split()
        if not parts:
            continue
            
        command, args = parts[0], parts[1:]
        
        if command == 'exit':
            break
        elif command in command_handlers:
            command_handlers[command](args)
        else:
            print(f"Неизвестная команда: {command}")
 
if __name__ == '__main__':
    main()

from prompt_toolkit import PromptSession
from prompt_toolkit.completion import Completer, Completion
 
class CustomCompleter(Completer):
    def __init__(self, commands):
        self.commands = commands
        
    def get_completions(self, document, complete_event):
        # Получаем текст до курсора
        text_before_cursor = document.text_before_cursor
        
        # Разбиваем на части, чтобы понять контекст
        parts = text_before_cursor.split()
        
        # Если ничего не введено или пробел в конце - предлагаем все команды
        if not parts or text_before_cursor.endswith(' '):
            for cmd in self.commands:
                yield Completion(cmd, start_position=0)
        # Иначе ищем совпадения с тем, что уже введено
        else:
            last_word = parts[-1]
            for cmd in self.commands:
                if cmd.startswith(last_word):
                    # Вычисляем, сколько символов нужно заменить
                    replace_len = len(last_word)
                    yield Completion(cmd, start_position=-replace_len)
 
def main():
    commands = ['help', 'status', 'load', 'save', 'exit']
    session = PromptSession(completer=CustomCompleter(commands))
    
    while True:
        user_input = session.prompt('> ')
        if user_input.strip() == 'exit':
            break
        print(f"Выполняется: {user_input}")
 
if __name__ == '__main__':
    main()

from prompt_toolkit import PromptSession
from prompt_toolkit.completion import NestedCompleter
 
def main():
    # Структура команд с вложенными подкомандами
    completer = NestedCompleter.from_nested_dict({
        'show': {
            'status': None,
            'log': None,
            'users': None,
        },
        'set': {
            'name': None,
            'age': None,
        },
        'exit': None,
    })
    
    session = PromptSession(completer=completer)
    
    while True:
        user_input = session.prompt('> ')
        if user_input.strip() == 'exit':
            break
        print(f"Выполняется: {user_input}")
 
if __name__ == '__main__':
    main()

from prompt_toolkit import PromptSession
from prompt_toolkit.lexers import Lexer
from prompt_toolkit.styles.named_colors import NAMED_COLORS
from prompt_toolkit.styles import Style
 
class CommandLexer(Lexer):
    def lex_document(self, document):
        def get_line(lineno):
            line = document.lines[lineno]
            parts = line.split()
            
            if not parts:
                return []
            
            # Выделяем команду зелёным, аргументы - синим
            command, args = parts[0], ' '.join(parts[1:])
            tokens = [
                (0, len(command), 'command'),
            ]
            
            if args:
                tokens.append((len(command) + 1, len(line), 'argument'))
            
            return tokens
        
        return get_line
 
def main():
    # Определяем стили для разных типов токенов
    style = Style.from_dict({
        'command': '#00AA00',  # Зелёный для команд
        'argument': '#0000AA', # Синий для аргументов
    })
    
    session = PromptSession(lexer=CommandLexer(), style=style)
    
    while True:
        user_input = session.prompt('> ')
        if user_input.strip() == 'exit':
            break
        print(f"Выполняется: {user_input}")
 
if __name__ == '__main__':
    main()

from prompt_toolkit import PromptSession
from prompt_toolkit.validation import Validator, ValidationError
 
class NumberValidator(Validator):
    def validate(self, document):
        text = document.text
        if not text.isdigit():
            raise ValidationError(message='Пожалуйста, введите число')
 
session = PromptSession(validator=NumberValidator())
number = session.prompt('Введите число: ')
print(f'Вы ввели число: {number}')

from prompt_toolkit import PromptSession
from prompt_toolkit.history import FileHistory
 
session = PromptSession(history=FileHistory('.myapp-history'))

from prompt_toolkit import PromptSession
from prompt_toolkit.validation import Validator, ValidationError
 
class CommandValidator(Validator):
    def validate(self, document):
        text = document.text
        
        # Базовая проверка на пустую строку
        if not text.strip():
            raise ValidationError(message='Команда не может быть пустой')
            
        # Проверка на допустимые команды
        valid_commands = ['help', 'status', 'load', 'save', 'exit']
        command = text.split()[0]
        
        if command not in valid_commands:
            raise ValidationError(
                message=f'Неизвестная команда: {command}. Доступные команды: {", ".join(valid_commands)}',
                cursor_position=len(command)  # Подсветка только команды, не всего ввода
            )
 
session = PromptSession(validator=CommandValidator())

class LoadCommandValidator(Validator):
    def validate(self, document):
        text = document.text.strip()
        parts = text.split()
        
        if not parts:
            return  # Пустой ввод пока допустим, пользователь ещё печатает
            
        if parts[0] != 'load':
            return  # Это не команда load, пусть другие валидаторы разбираются
            
        if len(parts) < 2:
            raise ValidationError(
                message='Укажите имя файла: load <filename>',
                cursor_position=len(text)
            )
            
        filename = parts[1]
        import os
        if not os.path.exists(filename):
            raise ValidationError(
                message=f'Файл {filename} не существует',
                cursor_position=len(parts[0]) + 1 + len(filename)
            )

class IntegerValidator(Validator):
    def __init__(self, min_value=None, max_value=None):
        self.min_value = min_value
        self.max_value = max_value
        
    def validate(self, document):
        text = document.text
        
        if not text.strip():
            return  # Пустая строка - пользователь ещё печатает
            
        try:
            value = int(text)
        except ValueError:
            raise ValidationError(message='Введите целое число')
            
        if self.min_value is not None and value < self.min_value:
            raise ValidationError(message=f'Значение должно быть не меньше {self.min_value}')
            
        if self.max_value is not None and value > self.max_value:
            raise ValidationError(message=f'Значение должно быть не больше {self.max_value}')
 
# Использование
age = session.prompt('Введите возраст: ', validator=IntegerValidator(min_value=0, max_value=120))

try:
    with open(filename, 'w') as f:
        f.write(data)
except PermissionError:
    print('\033[91mОшибка: недостаточно прав для записи в файл. Попробуйте выбрать другой путь.\033[0m')
except IOError as e:
    print(f'\033[91mНе удалось сохранить данные: {str(e)}\033[0m')

def handle_unknown_command(command):
    import difflib
    valid_commands = ['help', 'status', 'load', 'save', 'exit']
    # Ищем похожие команды
    matches = difflib.get_close_matches(command, valid_commands)
    
    if matches:
        print(f"Команда '{command}' не найдена. Возможно, вы имели в виду: {', '.join(matches)}?")
    else:
        print(f"Неизвестная команда: {command}. Введите 'help' для списка доступных команд.")

class LazyCompleter(Completer):
    def __init__(self, get_completions_func):
        self.get_completions_func = get_completions_func
        
    def get_completions(self, document, complete_event):
        word_before_cursor = document.get_word_before_cursor()
        
        # Не начинаем поиск, пока пользователь не набрал хотя бы 2 символа
        if len(word_before_cursor) < 2:
            return
            
        # Получаем только первые 100 совпадений для мгновенной реакции
        for completion in islice(self.get_completions_func(word_before_cursor), 100):
            yield completion

from functools import lru_cache
 
class CachedCompleter(Completer):
    def __init__(self, base_completer):
        self.base_completer = base_completer
        
    def get_completions(self, document, complete_event):
        return self.get_cached_completions(document.text_before_cursor, document.cursor_position)
            
    @lru_cache(maxsize=1000)
    def get_cached_completions(self, text, position):
        # Создаём новый документ, так как оригинальный нельзя хэшировать для lru_cache
        from prompt_toolkit.document import Document
        doc = Document(text, position)
        return list(self.base_completer.get_completions(doc, None))

class LazyValidator(Validator):
    def __init__(self, immediate_validator=None, full_validator=None):
        # Лёгкий валидатор для мгновенной обратной связи
        self.immediate_validator = immediate_validator
        # Тяжелый валидатор для финальной проверки
        self.full_validator = full_validator
        
    def validate(self, document):
        # Сначала запускаем лёгкую проверку
        if self.immediate_validator:
            self.immediate_validator.validate(document)
            
        # Тяжелую проверку запускаем только если пользователь закончил ввод
        # (например, по наличию определенного символа в конце)
        if document.text.endswith(';') and self.full_validator:
            self.full_validator.validate(document)

from prompt_toolkit.history import InMemoryHistory, FileHistory
 
# Ограничиваем историю последними 1000 командами
class LimitedHistory(FileHistory):
    def __init__(self, filename, max_entries=1000):
        super().__init__(filename)
        self.max_entries = max_entries
        self._loaded_strings = self._loaded_strings[-max_entries:] if len(self._loaded_strings) > max_entries else self._loaded_strings
        
    def append_string(self, string):
        super().append_string(string)
        if len(self._loaded_strings) > self.max_entries:
            self._loaded_strings = self._loaded_strings[-self.max_entries:]

async def main():
    session = PromptSession()
    
    # Запускаем фоновые задачи параллельно с вводом
    background_task = asyncio.create_task(background_processing())
    
    try:
        while True:
            command = await session.prompt_async('> ')
            # Обработка команды...
    finally:
        # Корректно завершаем фоновые задачи
        background_task.cancel()
        try:
            await background_task
        except asyncio.CancelledError:
            pass

from prompt_toolkit.validation import Validator, ValidationError
 
class EmailValidator(Validator):
    def validate(self, document):
        text = document.text
        
        if not text:  # Пустой ввод разрешен на этапе набора
            return
            
        if '@' not in text:
            raise ValidationError(message='Email должен содержать символ @')
            
        if not text.split('@')[1].strip():
            raise ValidationError(message='Укажите домен после @')
            
        # Можно добавить более сложные проверки для доменов, спецсимволов и т.д.

class DateValidator(Validator):
    def validate(self, document):
        text = document.text
        
        if not text:
            return
            
        try:
            from datetime import datetime
            # Пробуем распарсить дату в формате ДД.ММ.ГГГГ
            datetime.strptime(text, '%d.%m.%Y')
        except ValueError:
            raise ValidationError(message='Неверный формат даты. Используйте формат ДД.ММ.ГГГГ')
 
 
class URLValidator(Validator):
    def validate(self, document):
        text = document.text
        
        if not text:
            return
            
        if not (text.startswith('http://') or text.startswith('https://')):
            raise ValidationError(message='URL должен начинаться с http:// или https://')
            
        # Дополнительные проверки...

class SQLQueryValidator(Validator):
    def __init__(self, allowed_tables=None):
        self.allowed_tables = allowed_tables or []
        
    def validate(self, document):
        text = document.text.lower()
        
        if not text:
            return
            
        # Запрещаем опасные операции
        dangerous_keywords = ['drop', 'truncate', 'delete without where', 'update without where']
        for keyword in dangerous_keywords:
            if keyword in text:
                raise ValidationError(message=f'Потенциально опасная операция: {keyword}')
        
        # Проверяем, обращается ли запрос только к разрешенным таблицам
        if self.allowed_tables:
            import re
            tables_in_query = re.findall(r'from\s+(\w+)', text)
            for table in tables_in_query:
                if table not in self.allowed_tables:
                    raise ValidationError(message=f'Таблица {table} не доступна для запросов')

class CompositeValidator(Validator):
    def __init__(self, validators):
        self.validators = validators
        
    def validate(self, document):
        # Документ валиден, если прошел хотя бы через один валидатор
        text = document.text
        errors = []
        
        for validator in self.validators:
            try:
                validator.validate(document)
                return  # Валидация прошла успешно
            except ValidationError as e:
                errors.append(str(e))
        
        # Если ни один валидатор не сработал, выбрасываем ошибку
        raise ValidationError(message='Неверный формат ввода: ' + '; '.join(errors))
 
# Использование
number_or_auto = CompositeValidator([
    IntegerValidator(),
    Validator(lambda text: None if text == 'auto' else ValidationError('Ожидается число или "auto"'))
])

class ContextAwareValidator(Validator):
    def validate(self, document):
        text = document.text
        parts = text.split()
        
        if not parts:
            return
            
        command = parts[0]
        
        if command == 'set-timer' and len(parts) > 1:
            # Для команды set-timer ожидаем время в формате ЧЧ:ММ:СС
            try:
                import re
                if not re.match(r'^\d{2}:\d{2}:\d{2}$', parts[1]):
                    raise ValidationError(
                        message='Неверный формат времени. Используйте ЧЧ:ММ:СС',
                        cursor_position=len(command) + 1
                    )
            except Exception:
                raise ValidationError(
                    message='Неверный формат времени',
                    cursor_position=len(command) + 1
                )

def handle_help(args):
    if not args:
        print("\nДоступные команды:\n")
        print("  help [command]   - Показать справку о команде")
        print("  load <filename>  - Загрузить данные из файла")
        print("  save <filename>  - Сохранить данные в файл")
        print("  status           - Показать текущий статус")
        print("  exit             - Выйти из программы\n")
    else:
        command = args[0]
        if command == "load":
            print("\nload <filename> - Загружает данные из указанного файла.")
            print("Поддерживаемые форматы: .json, .csv, .xml\n")
        elif command == "save":
            print("\nsave <filename> - Сохраняет текущие данные в указанный файл.")
            print("Если расширение не указано, используется .json\n")
        else:
            print(f"Справка по команде '{command}' отсутствует.")

# Словарь с документацией по командам
COMMAND_DOCS = {
    'load': {
        'syntax': 'load <filename>',
        'description': 'Загружает данные из указанного файла.',
        'examples': ['load data.json', 'load ~/documents/config.xml'],
        'args': [{'name': 'filename', 'description': 'Путь к файлу для загрузки'}]
    },
    'save': {
        'syntax': 'save <filename>',
        'description': 'Сохраняет текущие данные в указанный файл.',
        'examples': ['save output.json', 'save ./backup/data.csv'],
        'args': [{'name': 'filename', 'description': 'Путь для сохранения файла'}]
    }
    # И так далее для других команд...
}
 
def show_documentation(command=None):
    if command is None:
        # Показываем список всех команд
        print("\nДоступные команды:\n")
        for cmd, data in COMMAND_DOCS.items():
            print(f"  {data['syntax']:<20} - {data['description']}")
        return
    
    if command not in COMMAND_DOCS:
        print(f"Справка по команде '{command}' отсутствует.")
        return
    
    doc = COMMAND_DOCS[command]
    print(f"\n{doc['syntax']}\n")
    print(f"Описание: {doc['description']}\n")
    
    if doc.get('args'):
        print("Аргументы:")
        for arg in doc['args']:
            print(f"  {arg['name']:<15} - {arg['description']}")
        print()
    
    if doc.get('examples'):
        print("Примеры:")
        for example in doc['examples']:
            print(f"  {example}")
        print()

from prompt_toolkit.formatted_text import HTML
from prompt_toolkit import PromptSession
from prompt_toolkit.completion import Completer, Completion
 
class DocumentedCompleter(Completer):
    def __init__(self, commands_docs):
        self.commands_docs = commands_docs
        
    def get_completions(self, document, complete_event):
        text = document.text_before_cursor
        word = document.get_word_before_cursor()
        
        for command, doc in self.commands_docs.items():
            if command.startswith(word):
                display_meta = doc['description']
                yield Completion(
                    command, 
                    start_position=-len(word),
                    display_meta=display_meta
                )
 
# Использование
session = PromptSession(
    completer=DocumentedCompleter(COMMAND_DOCS),
    complete_while_typing=True
)

from prompt_toolkit.layout.containers import Window
from prompt_toolkit.layout.controls import FormattedTextControl
from prompt_toolkit.layout.dimension import Dimension
 
class DocumentationBar:
    def __init__(self, command_docs):
        self.command_docs = command_docs
        self.current_text = ""
        
    def get_formatted_text(self):
        if not self.current_text:
            return [("class:doc", "Введите команду или 'help' для списка команд")]
        
        parts = self.current_text.strip().split()
        if not parts:
            return [("class:doc", "Введите команду или 'help' для списка команд")]
            
        command = parts[0]
        if command not in self.command_docs:
            return [("class:doc", f"Неизвестная команда: {command}")]
            
        doc = self.command_docs[command]
        return [("class:doc.syntax", f"{doc['syntax']} - {doc['description']}")]
    
    def create_window(self):
        return Window(
            FormattedTextControl(self.get_formatted_text),
            height=Dimension(min=1, max=1)
        )

from prompt_toolkit.shortcuts import radiolist_dialog
 
result = radiolist_dialog(
    title="Выберите режим работы",
    text="Доступные режимы:",
    values=[
        ("debug", "Отладка - подробный вывод всех операций"),
        ("normal", "Обычный режим - только важные сообщения"),
        ("silent", "Тихий режим - никаких уведомлений")
    ]
).run()
 
print(f"Выбран режим: {result}")

from prompt_toolkit.shortcuts import checkboxlist_dialog, message_dialog, yes_no_dialog, input_dialog
 
# Диалог с множественным выбором
options = checkboxlist_dialog(
    title="Настройка параметров",
    text="Выберите требуемые опции:",
    values=[
        ("logging", "Включить логирование"),
        ("autocommit", "Автоматическое сохранение"),
        ("backup", "Создавать резервные копии")
    ]
).run()
 
# Информационное сообщение
message_dialog(
    title="Операция завершена",
    text="Все данные успешно обработаны!"
).run()
 
# Запрос подтверждения
if yes_no_dialog(
    title="Внимание!",
    text="Вы уверены, что хотите удалить все файлы?"
).run():
    # Выполняем удаление
    pass
 
# Ввод текста в диалоге
name = input_dialog(
    title="Регистрация",
    text="Введите ваше имя:"
).run()

from prompt_toolkit import Application
from prompt_toolkit.buffer import Buffer
from prompt_toolkit.layout.containers import HSplit, Window
from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
from prompt_toolkit.layout.layout import Layout
 
# Создаём буфер для хранения и редактирования текста
buffer = Buffer()
buffer.text = "def hello_world():\n    print('Hello, world!')\n"
 
# Формируем пользовательский интерфейс
root_container = HSplit([
    # Заголовок
    Window(height=1, content=FormattedTextControl("Редактор кода - Ctrl+Q для выхода")),
    # Редактор
    Window(content=BufferControl(buffer=buffer)),
    # Статусная строка
    Window(height=1, content=FormattedTextControl("Готово к редактированию"))
])
 
# Создаём и запускаем приложение
layout = Layout(root_container)
app = Application(layout=layout, full_screen=True)
result = app.run()
 
# По завершении, можно использовать введёный текст
print(f"Вы ввели:\n{buffer.text}")

from prompt_toolkit.styles import Style
 
# Определяем набор стилей
style = Style.from_dict({
    # Классы для основных элементов интерфейса
    'dialog':             'bg:#222222',
    'dialog.body':        'bg:#000000 #ffffff',
    'dialog.title':       'bg:#0000aa #ffffff',
    
    # Стили для кнопок
    'button':             'bg:#222222',
    'button.focused':     'bg:#aaaaaa #000000',
    
    # Стили для текстовых элементов
    'text-area':          'bg:#000000 #ffffff',
    'text-area.cursor':   'bg:#aaaaaa',
    
    # Кастомные классы для нашего приложения
    'status.bar':         'bg:#222222 #aaaaaa',
    'error.message':      'bg:#550000 #ffffff bold',
    'warning.message':    'bg:#553300 #ffffff',
    'success.message':    'bg:#005500 #ffffff',
})
 
# Применяем стиль к приложению
app = Application(style=style, ...)

from prompt_toolkit.formatted_text import HTML
from prompt_toolkit import print_formatted_text
 
print_formatted_text(HTML(
    '<style bg="blue" fg="white">Информация: </style> '
    'Процесс завершён успешно. Обработано <i>145</i> файлов за <b>3.2</b> секунды.'
))

class DynamicStyle:
    def __init__(self):
        self.is_error_mode = False
        
    def get_style(self):
        # Базовые стили, общие для всех режимов
        styles = {
            'prompt': 'bold',
            'bottom-toolbar': 'bg:#222222 #aaaaaa',
        }
        
        # Добавляем специфичные стили в зависимости от режима
        if self.is_error_mode:
            styles.update({
                'prompt': 'bg:#550000 #ffffff bold',
                'bottom-toolbar': 'bg:#550000 #ffffff',
            })
        
        return Style.from_dict(styles)
 
# Использование
dynamic_style = DynamicStyle()
session = PromptSession(style=lambda: dynamic_style.get_style())
 
# При возникновении ошибки
dynamic_style.is_error_mode = True

from prompt_toolkit.layout.containers import VSplit, HSplit, Window
from prompt_toolkit.layout.dimension import Dimension
 
# Создаём сложный интерфейс, разделённый на зоны
layout = Layout(
    HSplit([
        # Верхняя панель - заголовок
        Window(height=1, content=FormattedTextControl('Мониторинг системы')),
        
        # Основная область - разделена на две колонки
        VSplit([
            # Левая панель - список ресурсов
            Window(width=Dimension(preferred=30, max=40), content=FormattedTextControl('Список ресурсов...')),
            
            # Правая панель - детальная информация
            Window(content=FormattedTextControl('Детальная информация...'))
        ]),
        
        # Нижняя панель - статусная строка
        Window(height=1, content=FormattedTextControl('Готово | Память: 45% | CPU: 12%'))
    ])
)

from prompt_toolkit.key_binding import KeyBindings
 
kb = KeyBindings()
 
@kb.add('c-q')  # Ctrl+Q
def exit_(event):
    """Выход из приложения."""
    event.app.exit()
 
@kb.add('c-s')  # Ctrl+S
def save(event):
    """Сохранение данных."""
    event.app.current_buffer.save_to_disk()
 
@kb.add('f5')  # F5
def refresh(event):
    """Обновление данных."""
    event.app.refresh_screen()

@kb.add('i', filter=vi_navigation_mode)
def enter_insertion_mode(event):
    event.app.vi_state.input_mode = InputMode.INSERT
 
@kb.add('escape', filter=vi_insertion_mode)
def enter_navigation_mode(event):
    event.app.vi_state.input_mode = InputMode.NAVIGATION

import asyncio
from prompt_toolkit import PromptSession
from prompt_toolkit.patch_stdout import patch_stdout
 
async def main():
    session = PromptSession()
    
    # Важно использовать patch_stdout при смешивании асинхронного ввода и обычного вывода
    with patch_stdout():
        while True:
            try:
                result = await session.prompt_async('> ')
                print(f'Вы ввели: {result}')
            except KeyboardInterrupt:
                return
            except EOFError:
                return
 
asyncio.run(main())

async def background_task():
    while True:
        # Имитация длительной операции
        await asyncio.sleep(5)
        print('\nФоновая задача выполняет действие...')
 
async def main():
    session = PromptSession()
    
    # Запускаем фоновую задачу
    background_job = asyncio.create_task(background_task())
    
    try:
        with patch_stdout():
            while True:
                command = await session.prompt_async('> ')
                if command == 'exit':
                    break
                print(f'Выполняется: {command}')
    finally:
        # Корректно завершаем фоновую задачу
        background_job.cancel()
        try:
            await background_job
        except asyncio.CancelledError:
            pass
 
asyncio.run(main())

from prompt_toolkit.application import Application
from prompt_toolkit.layout import Layout
from prompt_toolkit.key_binding import KeyBindings
 
kb = KeyBindings()
 
@kb.add('c-c')
def _(event):
    """Выход по Ctrl+C."""
    event.app.exit()
 
@kb.add('c-space')
def _(event):
    """Реакция на Ctrl+Space."""
    print("Активирована специальная функция!")
 
app = Application(key_bindings=kb, full_screen=True)
app.run()

import asyncio
from prompt_toolkit.application import Application
from prompt_toolkit.layout import Layout, Window
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.widgets import TextArea
from prompt_toolkit.layout.containers import HSplit
from prompt_toolkit.formatted_text import HTML
 
kb = KeyBindings()
status_bar_text = HTML("<ansired>Ожидание...</ansired>")
 
async def slow_operation():
    global status_bar_text
    status_bar_text = HTML("<ansigreen>Выполняется операция...</ansigreen>")
    await asyncio.sleep(3)  # Имитация длительной операции
    status_bar_text = HTML("<ansiblue>Операция завершена!</ansiblue>")
    await asyncio.sleep(2)
    status_bar_text = HTML("<ansired>Ожидание...</ansired>")
 
@kb.add('f5')
async def _(event):
    """Запуск асинхронной операции по F5."""
    # Создаём и запускаем задачу, но не ждём её завершения
    asyncio.create_task(slow_operation())
 
@kb.add('c-q')
def _(event):
    """Выход по Ctrl+Q."""
    event.app.exit()
 
def get_status_text():
    return status_bar_text
 
text_area = TextArea(text="Нажмите F5 для запуска операции или Ctrl+Q для выхода")
status_bar = Window(height=1, content=get_status_text)
 
app = Application(
    layout=Layout(HSplit([text_area, status_bar])),
    key_bindings=kb,
    full_screen=True
)
 
app.run()

import time
from prompt_toolkit import print_formatted_text
from prompt_toolkit.formatted_text import HTML
 
def spinner_animation():
    frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
    for _ in range(10):  # Крутимся 10 циклов
        for frame in frames:
            print_formatted_text(HTML(f"<ansiyellow>{frame}</ansiyellow> Загрузка данных..."), end='\r')
            time.sleep(0.1)
    print()  # Новая строка после окончания
 
spinner_animation()

import time
import asyncio
from prompt_toolkit import print_formatted_text
from prompt_toolkit.formatted_text import HTML
from prompt_toolkit.patch_stdout import patch_stdout
 
async def progress_bar(total, description="Прогресс"):
    with patch_stdout():
        for i in range(total + 1):
            percentage = i / total
            bar_length = 40
            filled_length = int(bar_length * percentage)
            
            # Изменяем цвет в зависимости от прогресса
            if percentage < 0.3:
                color = "red"
            elif percentage < 0.6:
                color = "yellow"
            else:
                color = "green"
                
            bar = '█' * filled_length + '░' * (bar_length - filled_length)
            
            print_formatted_text(
                HTML(f"<{color}>{description}: [{bar}] {percentage:.1%}</{color}>"),
                end='\r'
            )
            
            await asyncio.sleep(0.05)  # Имитация работы
        
        print()  # Новая строка после завершения
 
asyncio.run(progress_bar(100, "Скачивание файлов"))

import asyncio
from prompt_toolkit import print_formatted_text
from prompt_toolkit.formatted_text import HTML
from prompt_toolkit.patch_stdout import patch_stdout
 
async def typewriter_effect(text, delay=0.07):
    with patch_stdout():
        for char in text:
            print_formatted_text(char, end='', flush=True)
            await asyncio.sleep(delay)
        print()  # Новая строка в конце
 
asyncio.run(typewriter_effect("Добро пожаловать в будущее консольных интерфейсов!"))

import asyncio
import colorsys
from prompt_toolkit import print_formatted_text
from prompt_toolkit.formatted_text import FormattedText
from prompt_toolkit.patch_stdout import patch_stdout
 
async def rainbow_background(text, cycles=3):
    with patch_stdout():
        width = 60  # Ширина текстового поля
        
        # Создаём пустой блок нужной ширины
        blank = ' ' * width
        
        for cycle in range(cycles * 100):
            # Преобразуем HSV в RGB для плавного перехода цвета
            h = cycle / 100.0
            r, g, b = colorsys.hsv_to_rgb(h, 0.8, 0.8)
            
            # Конвертируем в диапазон 0-255
            r, g, b = int(r*255), int(g*255), int(b*255)
            
            # Создаём строку с фоновым цветом
            style = f'bg:#{r:02x}{g:02x}{b:02x}'
            
            # Центрируем текст
            padded_text = text.center(width)
            
            # Выводим строки с цветным фоном
            tokens = FormattedText([
                (style, blank),
                (style, padded_text),
                (style, blank)
            ])
            
            print_formatted_text(tokens, end='\r')
            await asyncio.sleep(0.02)
        
        print("\n" * 3)  # Очистка после завершения
 
asyncio.run(rainbow_background("✨ Prompt Toolkit Rocks! ✨"))

# translations.py
messages = {
    'en': {
        'welcome': 'Welcome to our CLI!',
        'prompt': 'Enter command: ',
        'goodbye': 'Thank you for using our tool!',
        'not_found': 'Command not found: {}',
    },
    'ru': {
        'welcome': 'Добро пожаловать в наш CLI!',
        'prompt': 'Введите команду: ',
        'goodbye': 'Спасибо за использование нашего инструмента!',
        'not_found': 'Команда не найдена: {}',
    },
    'de': {
        'welcome': 'Willkommen in unserem CLI!',
        'prompt': 'Befehl eingeben: ',
        'goodbye': 'Vielen Dank für die Nutzung unseres Tools!',
        'not_found': 'Befehl nicht gefunden: {}',
    }
}

def get_message(key, language='en', *args, **kwargs):
    if language not in messages:
        language = 'en'  # Фолбэк на английский
    
    message = messages[language].get(key, messages['en'].get(key, key))
    if args or kwargs:
        return message.format(*args, **kwargs)
    return message

import locale
from prompt_toolkit import prompt
from translations import get_message
 
# Определяем язык системы или используем переданный параметр
def get_system_language():
    try:
        # Пытаемся получить настройки локали
        system_locale = locale.getlocale()[0]
        if system_locale:
            return system_locale.split('_')[0]
    except:
        pass
    return 'en'
 
user_language = get_system_language()
print(get_message('welcome', user_language))
 
while True:
    command = prompt(get_message('prompt', user_language))
    if command == 'exit':
        print(get_message('goodbye', user_language))
        break
    # Обработка команды...

from babel.dates import format_date, format_time
from babel.numbers import format_number, format_currency
import datetime
 
# Форматирование даты согласно локали
now = datetime.datetime.now()
print(format_date(now, locale='en_US'))  # Sept 15, 2023
print(format_date(now, locale='de_DE'))  # 15.09.2023
print(format_date(now, locale='ja_JP'))  # 2023/09/15
 
# Форматирование чисел
amount = 1234.56
print(format_number(amount, locale='en_US'))  # 1,234.56
print(format_number(amount, locale='de_DE'))  # 1.234,56
print(format_number(amount, locale='ru_RU'))  # 1 234,56
 
# Валюта
print(format_currency(amount, 'USD', locale='en_US'))  # $1,234.56
print(format_currency(amount, 'EUR', locale='de_DE'))  # 1.234,56 €

import sys
import codecs
 
# Настройка кодировки для ввода/вывода
if sys.stdout.encoding != 'utf-8':
    sys.stdout = codecs.getwriter('utf-8')(sys.stdout.buffer, 'strict')
if sys.stderr.encoding != 'utf-8':
    sys.stderr = codecs.getwriter('utf-8')(sys.stderr.buffer, 'strict')

# task_manager.py
import asyncio
import json
import os
from datetime import datetime
from typing import Dict, List, Optional, Union, Any
 
from prompt_toolkit import PromptSession, print_formatted_text, HTML
from prompt_toolkit.completion import NestedCompleter
from prompt_toolkit.formatted_text import FormattedText
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.validation import Validator, ValidationError
from prompt_toolkit.shortcuts import radiolist_dialog, input_dialog, yes_no_dialog
from prompt_toolkit.styles import Style
from prompt_toolkit.patch_stdout import patch_stdout
 
# Определение модели данных
class Task:
    def __init__(self, title: str, priority: str = 'medium', 
                 category: str = 'general', due_date: Optional[str] = None,
                 completed: bool = False):
        self.id = None  # Будет установлен при добавлении в TaskManager
        self.title = title
        self.priority = priority
        self.category = category
        self.due_date = due_date
        self.completed = completed
        self.created_at = datetime.now().isoformat()
        
    def to_dict(self) -> Dict[str, Any]:
        return {
            'id': self.id,
            'title': self.title,
            'priority': self.priority,
            'category': self.category,
            'due_date': self.due_date,
            'completed': self.completed,
            'created_at': self.created_at
        }
    
    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> 'Task':
        task = cls(
            title=data['title'],
            priority=data.get('priority', 'medium'),
            category=data.get('category', 'general'),
            due_date=data.get('due_date'),
            completed=data.get('completed', False)
        )
        task.id = data.get('id')
        task.created_at = data.get('created_at', datetime.now().isoformat())
        return task

class TaskManager:
    def __init__(self, data_file: str = 'tasks.json'):
        self.tasks: List[Task] = []
        self.data_file = data_file
        self.next_id = 1
        
    def add_task(self, task: Task) -> Task:
        task.id = self.next_id
        self.tasks.append(task)
        self.next_id += 1
        return task
    
    def get_task(self, task_id: int) -> Optional[Task]:
        for task in self.tasks:
            if task.id == task_id:
                return task
        return None
    
    def update_task(self, task_id: int, **kwargs) -> Optional[Task]:
        task = self.get_task(task_id)
        if not task:
            return None
        
        for key, value in kwargs.items():
            if hasattr(task, key):
                setattr(task, key, value)
        
        return task
    
    def delete_task(self, task_id: int) -> bool:
        task = self.get_task(task_id)
        if not task:
            return False
        
        self.tasks.remove(task)
        return True
    
    def get_all_tasks(self) -> List[Task]:
        return self.tasks
    
    def get_tasks_by_category(self, category: str) -> List[Task]:
        return [task for task in self.tasks if task.category == category]
    
    def get_tasks_by_priority(self, priority: str) -> List[Task]:
        return [task for task in self.tasks if task.priority == priority]
    
    def search_tasks(self, query: str) -> List[Task]:
        query = query.lower()
        return [task for task in self.tasks 
                if query in task.title.lower() or 
                   query in task.category.lower()]
    
    async def save_to_file(self) -> None:
        """Асинхронно сохраняет задачи в файл"""
        with open(self.data_file, 'w') as f:
            json.dump({
                'next_id': self.next_id,
                'tasks': [task.to_dict() for task in self.tasks]
            }, f, indent=2)
    
    async def load_from_file(self) -> bool:
        """Асинхронно загружает задачи из файла"""
        if not os.path.exists(self.data_file):
            return False
        
        try:
            with open(self.data_file, 'r') as f:
                data = json.load(f)
                self.next_id = data.get('next_id', 1)
                self.tasks = [Task.from_dict(t) for t in data.get('tasks', [])]
            return True
        except (json.JSONDecodeError, KeyError):
            return False

class TaskApp:
    def __init__(self, manager: TaskManager, language: str = 'en'):
        self.manager = manager
        self.language = language
        self.session = PromptSession()
        self.running = False
        self.kb = KeyBindings()
        
        # Определение стилей для приложения
        self.style = Style.from_dict({
            'title': 'ansiyellow bold',
            'priority.high': 'ansired bold',
            'priority.medium': 'ansiyellow',
            'priority.low': 'ansigreen',
            'category': 'ansiblue',
            'task.completed': 'ansibrightblack',
            'status.bar': 'bg:ansibrightblack ansiwhite',
            'dialog': 'bg:ansiblack ansiwhite',
            'dialog.title': 'bg:ansiblue ansiwhite bold',
            'spinner': 'ansiyellow'
        })
        
        # Настройка комплитера команд
        self.completer = NestedCompleter.from_nested_dict({
            'add': None,
            'list': {
                'all': None,
                'category': None,
                'priority': {
                    'high': None,
                    'medium': None,
                    'low': None
                }
            },
            'edit': None,
            'delete': None,
            'search': None,
            'help': None,
            'exit': None
        })
        
        # Настройка горячих клавиш
        @self.kb.add('c-c')
        def _(event):
            """Выход по Ctrl+C."""
            self.running = False
            event.app.exit()
    
    # Переводы для интерфейса
    def get_message(self, key, *args, **kwargs):
        messages = {
            'en': {
                'welcome': 'Welcome to Task Manager! Type "help" for commands.',
                'prompt': 'Task Manager> ',
                'help_title': 'Available Commands:',
                'help_add': 'add - Add a new task',
                'help_list': 'list - List tasks (all/category/priority)',
                'help_edit': 'edit <id> - Edit a task',
                'help_delete': 'delete <id> - Delete a task',
                'help_search': 'search <query> - Search for tasks',
                'help_exit': 'exit - Exit the application',
                # ... другие переводы
            },
            'ru': {
                'welcome': 'Добро пожаловать в Менеджер Задач! Введите "help" для справки.',
                'prompt': 'Менеджер Задач> ',
                'help_title': 'Доступные команды:',
                'help_add': 'add - Добавить новую задачу',
                'help_list': 'list - Список задач (all/category/priority)',
                'help_edit': 'edit <id> - Редактировать задачу',
                'help_delete': 'delete <id> - Удалить задачу',
                'help_search': 'search <query> - Поиск задач',
                'help_exit': 'exit - Выйти из приложения',
                # ... другие переводы
            }
            # Можно добавить другие языки
        }
        
        if self.language not in messages:
            self.language = 'en'
            
        msg = messages[self.language].get(key, messages['en'].get(key, key))
        if args or kwargs:
            return msg.format(*args, **kwargs)
        return msg
    
    async def show_spinner(self, message, task):
        """Показывает анимированный спиннер во время выполнения задачи"""
        spinner_chars = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
        i = 0
        
        with patch_stdout():
            while not task.done():
                char = spinner_chars[i]
                i = (i + 1) % len(spinner_chars)
                print_formatted_text(
                    FormattedText([
                        ('class:spinner', char + ' '),
                        ('', message)
                    ]),
                    end='\r'
                )
                await asyncio.sleep(0.1)
            
            # Очищаем строку со спиннером
            print(' ' * (len(message) + 2), end='\r')

    async def handle_command(self, command: str) -> None:
        """Обрабатывает введенные пользователем команды"""
        parts = command.strip().split(maxsplit=1)
        cmd = parts[0].lower() if parts else ""
        args = parts[1] if len(parts) > 1 else ""
        
        if cmd == 'add':
            await self.add_task_dialog()
        elif cmd == 'list':
            await self.list_tasks(args)
        elif cmd == 'edit':
            try:
                task_id = int(args)
                await self.edit_task_dialog(task_id)
            except ValueError:
                print_formatted_text(HTML("<ansired>Invalid task ID!</ansired>"))
        elif cmd == 'delete':
            try:
                task_id = int(args)
                await self.delete_task_dialog(task_id)
            except ValueError:
                print_formatted_text(HTML("<ansired>Invalid task ID!</ansired>"))
        elif cmd == 'search':
            if not args:
                print_formatted_text(HTML("<ansired>Please provide a search query</ansired>"))
            else:
                await self.search_tasks(args)
        elif cmd == 'help':
            self.show_help()
        elif cmd == 'exit':
            self.running = False
        else:
            print_formatted_text(HTML(f"<ansired>Unknown command: {cmd}</ansired>"))
            
    async def add_task_dialog(self) -> None:
        """Диалог добавления новой задачи"""
        title = await asyncio.to_thread(
            lambda: input_dialog(
                title='Add Task',
                text='Enter task title:'
            ).run()
        )
        
        if not title:
            return
            
        priority = await asyncio.to_thread(
            lambda: radiolist_dialog(
                title='Task Priority',
                text='Select priority:',
                values=[
                    ('high', 'High'),
                    ('medium', 'Medium'),
                    ('low', 'Low')
                ],
                default='medium'
            ).run()
        )
        
        if not priority:
            priority = 'medium'
            
        category = await asyncio.to_thread(
            lambda: input_dialog(
                title='Task Category',
                text='Enter category:'
            ).run()
        )
        
        if not category:
            category = 'general'
            
        # Создаем и добавляем задачу
        task = Task(title=title, priority=priority, category=category)
        self.manager.add_task(task)
        
        # Асинхронно сохраняем в файл с анимацией
        save_task = asyncio.create_task(self.manager.save_to_file())
        await self.show_spinner("Saving task...", save_task)
        
        print_formatted_text(HTML(f"<ansigreen>Task added successfully!</ansigreen>"))

    async def run(self) -> None:
        """Запускает основной цикл приложения"""
        # Загружаем задачи из файла с анимацией
        load_task = asyncio.create_task(self.manager.load_from_file())
        await self.show_spinner("Loading tasks...", load_task)
        
        print_formatted_text(HTML(f"<ansiyellow>{self.get_message('welcome')}</ansiyellow>"))
        
        self.running = True
        with patch_stdout():
            while self.running:
                try:
                    command = await self.session.prompt_async(
                        self.get_message('prompt'),
                        completer=self.completer,
                        key_bindings=self.kb,
                        style=self.style
                    )
                    if command.strip():
                        await self.handle_command(command)
                except KeyboardInterrupt:
                    self.running = False
                except EOFError:
                    self.running = False
        
        # Сохраняем задачи перед выходом
        save_task = asyncio.create_task(self.manager.save_to_file())
        await self.show_spinner("Saving tasks before exit...", save_task)
        print_formatted_text(HTML("<ansigreen>Goodbye!</ansigreen>"))
 
# Запуск приложения
async def main():
    manager = TaskManager('tasks.json')
    app = TaskApp(manager)
    await app.run()
 
if __name__ == "__main__":
    asyncio.run(main())

async def list_tasks(self, args: str = '') -> None:
    """Отображает список задач с возможностью фильтрации"""
    parts = args.strip().split()
    filter_type = parts[0] if parts else 'all'
    
    tasks = []
    if filter_type == 'all':
        tasks = self.manager.get_all_tasks()
    elif filter_type == 'category' and len(parts) > 1:
        category = parts[1]
        tasks = self.manager.get_tasks_by_category(category)
    elif filter_type == 'priority' and len(parts) > 1:
        priority = parts[1]
        tasks = self.manager.get_tasks_by_priority(priority)
    else:
        tasks = self.manager.get_all_tasks()
    
    self._display_tasks(tasks)
 
async def search_tasks(self, query: str) -> None:
    """Ищет задачи по запросу"""
    tasks = self.manager.search_tasks(query)
    print_formatted_text(HTML(f"<ansiyellow>Search results for '{query}':</ansiyellow>"))
    self._display_tasks(tasks)
 
def _display_tasks(self, tasks: List[Task]) -> None:
    """Внутренний метод для форматированного отображения списка задач"""
    if not tasks:
        print_formatted_text(HTML("<ansibrightblack>No tasks found</ansibrightblack>"))
        return
        
    for task in tasks:
        title_style = 'task.completed' if task.completed else f'priority.{task.priority}'
        title_text = f"{task.title} {'✓' if task.completed else ''}"
        
        print_formatted_text(FormattedText([
            ('', f"[{task.id}] "),
            (f'class:{title_style}', title_text),
            ('', ' - '),
            ('class:category', task.category)
        ]))