Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

Напиши логику приложения (текстового редактора или плагина) на Python c функцией…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514’s answer.
  1. User

    Напиши логику приложения (текстового редактора или плагина) на Python c функцией автодополнения для корректировки ранее введенного текста.

  2. Gemini Assistant

    Отличная идея! Создание автодополнения для корректировки уже введенного текста — это более сложная и интересная задача, чем стандартное автодополнение текущего слова. Такая функция ближе к умному линтеру или ассистенту по написанию текстов.

    Давайте разберем логику такого приложения на Python. Мы создадим модульную систему, которую можно будет легко расширить.

    1. Концептуальная логика

    В основе системы лежат четыре ключевых компонента:

    1. Текстовый буфер (Text Buffer): Это просто текущее состояние текста, который ввел пользователь. В реальном приложении это будет содержимое текстового поля.
    2. Анализатор (Analyzer): Это "мозг" системы. Он периодически (или по триггеру) сканирует текст в буфере и ищет потенциальные проблемы: орфографические ошибки, опечатки, несогласованность терминологии, стилистические недочеты и т.д.
    3. Движок предложений (Suggestion Engine): Когда анализатор находит проблему, он передает ее в этот движок. Движок генерирует одно или несколько возможных исправлений.
    4. Пользовательский интерфейс (UI): Отображает найденные проблемы (например, подчеркиванием) и предлагает варианты исправления (всплывающее окно, контекстное меню).

    Процесс работы:

    1. Пользователь вводит или изменяет текст.
    2. Срабатывает триггер (например, пауза во вводе, ввод знака препинания, ручной запуск).
    3. Анализатор получает весь текст или его измененную часть.
    4. Анализатор разбивает текст на единицы (слова, предложения) и проверяет их по своим правилам.
    5. Для каждой найденной "проблемы" (например, слова "приветт") Анализатор запрашивает у Движка предложений варианты исправления ("привет").
    6. Система сохраняет найденные проблемы и их исправления, включая их позицию в тексте (индекс начала и конца).
    7. UI использует эту информацию, чтобы подчеркнуть проблемное слово и при наведении/клике показать предложенные варианты.

    2. Триггеры для анализа

    Эффективность системы сильно зависит от того, когда запускать анализ. Слишком частый запуск замедлит редактор, слишком редкий — сделает функцию бесполезной.

    • Пауза во вводе (On Idle): Самый сбалансированный подход. Если пользователь не печатает в течение 0.5-1 секунды, запускается анализ.
    • Специальный символ: Анализ запускается после ввода точки, запятой, восклицательного знака или нажатия Enter. Отлично подходит для проверки грамматики целых предложений.
    • По запросу: Пользователь нажимает кнопку или сочетание клавиш для запуска полной проверки документа.
    • При сохранении: Проверка всего документа перед сохранением файла.

    3. Практическая реализация на Python (консольный симулятор)

    Давайте напишем код, симулирующий эту логику. Мы сделаем систему модульной, где каждый тип проверки (орфография, терминология) будет отдельным классом-анализатором.

    import re
    import time
    from typing import List, Dict, Tuple, NamedTuple
    
    # --- Структуры данных ---
    
    class Problem(NamedTuple):
        """Описывает найденную проблему в тексте."""
        start_index: int
        end_index: int
        message: str
        suggestions: List[str]
    
    # --- Модули анализаторов ---
    
    class BaseAnalyzer:
        """Базовый класс для всех анализаторов."""
        def analyze(self, text: str) -> List[Problem]:
            raise NotImplementedError
    
    class SpellCheckAnalyzer(BaseAnalyzer):
        """Анализатор орфографии на основе простого словаря."""
        def __init__(self, known_words: set):
            self.known_words = known_words
            # Простое расстояние Левенштейна для поиска похожих слов
            # В реальном приложении лучше использовать более быструю библиотеку (например, pyxDamerauLevenshtein)
            from Levenshtein import distance as levenshtein_distance
            self.distance = levenshtein_distance
    
        def analyze(self, text: str) -> List[Problem]:
            problems = []
            # Ищем слова (последовательности букв)
            for match in re.finditer(r'\b[а-яА-ЯёЁa-zA-Z]+\b', text):
                word = match.group(0).lower()
                if word not in self.known_words:
                    # Нашли ошибку, ищем предложения
                    suggestions = []
                    # Ищем слова с расстоянием Левенштейна 1 или 2
                    for known_word in self.known_words:
                        if self.distance(word, known_word) <= 2:
                            suggestions.append(known_word)
                    
                    problem = Problem(
                        start_index=match.start(),
                        end_index=match.end(),
                        message=f"Возможная опечатка в слове '{match.group(0)}'",
                        suggestions=suggestions[:5] # Ограничиваем количество предложений
                    )
                    problems.append(problem)
            return problems
    
    class TerminologyAnalyzer(BaseAnalyzer):
        """Анализатор для обеспечения согласованности терминологии."""
        def __init__(self, terminology_map: Dict[str, str]):
            # "неправильный термин": "правильный термин"
            self.term_map = terminology_map
    
        def analyze(self, text: str) -> List[Problem]:
            problems = []
            for bad_term, good_term in self.term_map.items():
                # Используем re.finditer для поиска всех вхождений
                # \b - граница слова, чтобы не находить "юзер" внутри "браузер"
                for match in re.finditer(r'\b' + re.escape(bad_term) + r'\b', text, re.IGNORECASE):
                    problem = Problem(
                        start_index=match.start(),
                        end_index=match.end(),
                        message=f"Термин '{match.group(0)}' лучше заменить на '{good_term}'",
                        suggestions=[good_term]
                    )
                    problems.append(problem)
            return problems
    
    # --- Основной класс-оркестратор ---
    
    class TextCorrector:
        """Главный класс, который управляет процессом анализа."""
        def __init__(self, analyzers: List[BaseAnalyzer]):
            self.analyzers = analyzers
            self.current_problems = []
    
        def analyze_text(self, text: str):
            """Запускает все анализаторы и собирает проблемы."""
            print("\n--- Запуск анализа текста ---")
            all_problems = []
            for analyzer in self.analyzers:
                problems = analyzer.analyze(text)
                if problems:
                    all_problems.extend(problems)
            
            # Сортируем проблемы по их позиции в тексте
            self.current_problems = sorted(all_problems, key=lambda p: p.start_index)
            self.display_problems(text)
    
        def display_problems(self, text: str):
            """Отображает найденные проблемы (симуляция UI)."""
            if not self.current_problems:
                print("Проблем не найдено.")
                return
    
            print("Найдены следующие проблемы:")
            for problem in self.current_problems:
                faulty_text = text[problem.start_index:problem.end_index]
                print(
                    f"  - Позиция {problem.start_index}-{problem.end_index}: '{faulty_text}'\n"
                    f"    > Сообщение: {problem.message}\n"
                    f"    > Предложения: {problem.suggestions}"
                )
    
    # --- Симуляция работы редактора ---
    
    if __name__ == "__main__":
        # Убедитесь, что у вас установлена библиотека: pip install python-Levenshtein
        try:
            import Levenshtein
        except ImportError:
            print("Пожалуйста, установите библиотеку: pip install python-Levenshtein")
            exit()
    
        # 1. Настраиваем наши анализаторы
        # Словарь для проверки орфографии
        dictionary = {"привет", "мир", "пользователь", "профиль", "система", "разработка", "текст"}
        spell_checker = SpellCheckAnalyzer(known_words=dictionary)
    
        # Словарь для проверки терминологии
        terms = {
            "юзер": "пользователь",
            "логин": "имя пользователя",
            "девелопмент": "разработка"
        }
        term_checker = TerminologyAnalyzer(terminology_map=terms)
    
        # 2. Создаем экземпляр корректора
        corrector = TextCorrector(analyzers=[spell_checker, term_checker])
    
        # 3. Симулируем ввод текста пользователем
        text_buffer = "Привеет, мир! Это текст про девелопмент. Юзер должен зайти в свой профиль."
        
        print("Исходный текст:")
        print(text_buffer)
    
        # Симулируем паузу в наборе, после которой запускается анализ
        print("\nПользователь сделал паузу в наборе...")
        time.sleep(1) 
        
        corrector.analyze_text(text_buffer)
    
        # 4. Пользователь исправляет текст (симуляция)
        print("\n--- Пользователь исправляет текст ---")
        # Допустим, он выбрал "привет" и "разработка"
        text_buffer = "Привет, мир! Это текст про разработка. Юзер должен зайти в свой профиль."
        print("Новый текст:")
        print(text_buffer)
        
        print("\nПользователь снова сделал паузу...")
        time.sleep(1)
    
        corrector.analyze_text(text_buffer)
    

    4. Усложненный вариант: Грамматика и интеграция с LLM

    Простую проверку по словарю можно улучшить.

    а) Использование готовых библиотек для грамматики:

    Можно подключить библиотеку вроде language_tool_python, которая является оберткой над мощным инструментом LanguageTool.

    import language_tool_python
    
    class GrammarAnalyzer(BaseAnalyzer):
        def __init__(self, language='ru-RU'):
            self.tool = language_tool_python.LanguageTool(language)
    
        def analyze(self, text: str) -> List[Problem]:
            problems = []
            matches = self.tool.check(text)
            for match in matches:
                problem = Problem(
                    start_index=match.offset,
                    end_index=match.offset + match.errorLength,
                    message=match.message,
                    suggestions=match.replacements
                )
                problems.append(problem)
            return problems
    
    # Использование:
    # grammar_checker = GrammarAnalyzer()
    # corrector = TextCorrector(analyzers=[spell_checker, term_checker, grammar_checker])
    

    б) Интеграция с большими языковыми моделями (LLM) для стилистики:

    Для более сложных задач (исправление стилистики, перефразирование) можно обращаться к API вроде GPT от OpenAI или к локально запущенной модели (Llama, Mistral).

    Логика LLMAnalyzer:

    1. Анализатор получает фрагмент текста (например, предложение или абзац).
    2. Он формирует специальный промпт для модели, например:

      "Найди и исправь стилистические и грамматические ошибки в следующем предложении. Ответ дай в формате JSON: {\"original\": \"фрагмент с ошибкой\", \"corrected\": \"исправленный фрагмент\", \"explanation\": \"почему это ошибка\"}. Текст для проверки: 'Этот код является очень плохим.'"

    3. Отправляет запрос к API модели.
    4. Парсит ответ и создает объект Problem с предложением по замене.

    Этот подход очень мощный, но требует сетевого подключения (если API) и может быть медленным и дорогим.

    5. Интеграция с UI (например, Tkinter или PyQt)

    • Привязка к событиям: Логика анализатора привязывается к событию изменения текста в текстовом поле (<<Modified>> в Tkinter или textChanged в PyQt).
    • Таймер: Чтобы не запускать анализ на каждое нажатие клавиши, используется таймер. Каждое нажатие сбрасывает таймер. Если таймер доходит до конца (например, 500 мс), запускается анализ.
    • Отображение: Найденные проблемы (Problem) используются для создания тегов форматирования. Например, в Tkinter можно создать тег с волнистым подчеркиванием (underline=True, underline_color='red') и применить его к тексту в диапазоне problem.start_index и problem.end_index.
    • Контекстное меню: При клике правой кнопкой мыши по подсвеченному тексту UI проверяет, есть ли Problem в этой позиции, и если да — формирует контекстное меню из problem.suggestions.

    Эта архитектура позволяет создать гибкое и расширяемое приложение, которое может значительно помочь пользователю в написании качественных текстов.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.