refactor

app.py

@@ -5,10 +5,7 @@ from generation import wrap_prompt
 from llm import get_llm_answer
 from retrieval import Retrieval
 from _2_splitting import _parse_single_year
-from vocabulary.parse_vocabulary import parse_vocabulary
-
-
-vocabulary, _ = parse_vocabulary('vocabulary/vocabulary.md')
+from vocabulary.parse_vocabulary import VOCABULARY_MANAGER
 
 
 class Perform:
@@ -98,7 +95,7 @@ def ask_llm(query, filtered_indices_state):
         return
     
     # Формируем промпт и отправляем в LLM
-    prompt = wrap_prompt(context, query, vocabulary)
+    prompt = wrap_prompt(context, query, VOCABULARY_MANAGER.vocabulary)
     
     # Потоковая выдача ответа
     full_answer = ""

lemmatizer.py

@@ -1,26 +1,10 @@
 # -*- coding: utf-8 -*-
-"""
-Общий модуль для лемматизации на русском языке с поддержкой пользовательских терминов.
-Используется в retrieval.py и test_lemmatization.py
-"""
-from pathlib import Path
 import spacy
-from vocabulary.parse_vocabulary import parse_vocabulary, extract_stem
+from vocabulary.parse_vocabulary import VOCABULARY_MANAGER
 
 
-class RussianLemmatizer:
-    """
-    Русский лемматизатор на основе spaCy с поддержкой пользовательских терминов.
-    Содержит общую логику для всех компонентов системы.
-    """
-    
-    def __init__(self, load_terms: bool = True):
-        """
-        Инициализация лемматизатора.
-        
-        Args:
-            load_terms: загружать ли термины из vocabulary.md при инициализации
-        """
+class RussianLemmatizer:    
+    def __init__(self):
         print("   Загрузка русской модели spaCy...")
         try:
             self.nlp = spacy.load("ru_core_news_sm")
@@ -33,27 +17,10 @@ class RussianLemmatizer:
         self.terms = {}
         self.stems = {}
         
-        if load_terms:
-            self._register_terms()
-    
-    def _register_terms(self):
-        """
-        Загружает термины из vocabulary/vocabulary.md и регистрирует их в spaCy
-        как custom component для исправления лемм.
-        """
-        # Находим файл vocabulary относительно этого модуля
-        vocab_file = Path(__file__).parent / "vocabulary" / "vocabulary.md"
-        
-        if not vocab_file.exists():
-            print(f"   ⚠️  Файл {vocab_file} не найден, управление терминами пропущено")
-            return
-        
-        # Парсим словарь термин -> описание и извлекаем информацию о корнях
-        vocab_dict, stems_dict = parse_vocabulary(str(vocab_file))
-        
+        # регистрация терминов
         # Создаём словарь для быстрого поиска (приводим к нижнему регистру)
-        self.terms = {term.lower(): term.lower() for term in vocab_dict.keys()}
-        self.stems = stems_dict
+        self.terms = {term.lower(): term.lower() for term in VOCABULARY_MANAGER.vocabulary}
+        self.stems = VOCABULARY_MANAGER.stems
         
         print(f"   Загружено {len(self.terms)} терминов из vocabulary.md")
         print(f"   Информация о корнях: {len(self.stems)} корней с окончаниями")
@@ -64,15 +31,9 @@ class RussianLemmatizer:
             """Компонент для исправления лемм терминов и их форм"""
             for token in doc:
                 lemma_lower = token.lemma_.lower()
-                
-                # Сначала проверяем прямое совпадение
-                if lemma_lower in self.terms:
-                    token.lemma_ = self.terms[lemma_lower]
-                else:
-                    # Если не нашли, пробуем найти по корню и окончанию
-                    canonical = extract_stem(lemma_lower, self.stems)
-                    if canonical:
-                        token.lemma_ = canonical.lower()
+                canonical = VOCABULARY_MANAGER.extract_stem(lemma_lower)
+                if canonical:
+                    token.lemma_ = canonical.lower()
             return doc
         
         # Добавляем компонент после лемматизатора
@@ -80,8 +41,7 @@ class RussianLemmatizer:
             self.nlp.add_pipe("fix_terms", after="lemmatizer")
     
     def tokenize_text(self, text: str) -> list[str]:
-        """
-        Лемматизация текста для русского языка (spaCy).
+        """Лемматизация текста для русского языка (spaCy).
         
         Args:
             text: текст для лемматизации

retrieval.py

@@ -66,7 +66,7 @@ class Retrieval:
         
         # Инициализация лемматизатора для русского языка
         print("   Инициализация лемматизатора...")
-        self.lemmatizer = RussianLemmatizer(load_terms=True)
+        self.lemmatizer = RussianLemmatizer()
         
         # Загружаем и обрабатываем данные
         print("1. Загрузка данных из JSON...")

tests/test_lemmatization.py

@@ -115,7 +115,7 @@ def test_lemmatization():
     print("="*70)
     
     # Инициализируем лемматизатор один раз
-    lemmatizer = RussianLemmatizer(load_terms=True)
+    lemmatizer = RussianLemmatizer()
     
     total_passed = 0
     total_failed = 0

vocabulary/__init__.py

@@ -1,5 +0,0 @@
-"""Vocabulary management module for RAG system."""
-
-from .vocabulary_manager import VocabularyManager
-
-__all__ = ["VocabularyManager"]

vocabulary/parse_vocabulary.py

@@ -1,121 +1,115 @@
-def parse_vocabulary(filepath):
-    """
-    Парсит файл vocabulary.md и возвращает два словаря:
-    
-    Формат файла:
-    ## Категория
-    ### Термин[окончание], Синоним1[окончание]
-    Определение термина
-    
-    Возвращает кортеж (vocabulary, stems):
-    - vocabulary: термин (без скобок) -> определение
-    - stems: корень -> информация об окончании
-    """
-    vocabulary = {}
-    stems = {}  # корень -> информация об окончании
-    
-    with open(filepath, 'r', encoding='utf-8') as f:
-        lines = f.readlines()
-    
-    i = 0
-    while i < len(lines):
-        line = lines[i].strip()
+from typing import Optional
+
+
+def parse_term(term_raw: str) -> tuple[str, str, Optional[str]]:
+    """Извлекает лемму термина, корень и окончание из строки термина"""
+    if "[" in term_raw and "]" in term_raw:
+        bracket_pos = term_raw.index("[")
+        stem = term_raw[:bracket_pos]
+        ending = term_raw[bracket_pos + 1: term_raw.index("]")]
+    else:
+        stem = term_raw
+        ending = None 
+        # важно, что не пустую строку! Есть пустое окончание, есть отсутствие окончания у несклоняемых мслов
+    term_lemma = term_raw.replace("[", "").replace("]", "")
+    return term_lemma, stem, ending
+
+
+class ParserVocabulary:
+    def __init__(self, filepath) -> None:
+        """
+        Парсит файл vocabulary.md и возвращает два словаря:
         
-        # Пропускаем категории (##)
-        if line.startswith('## '):
-            i += 1
-            continue
+        Формат файла:
+        ## Категория
+        ### Термин[окончание], Синоним1[окончание]
+        Определение термина
         
-        # Если это заголовок термина (начинается с ###)
-        if line.startswith('### '):
-            # Взять текст после ###
-            terms_line = line[4:].strip()
-            
-            # Разбить на отдельные термины (синонимы разделены ", ")
-            terms_raw = [term.strip() for term in terms_line.split(',')]
+        - vocabulary: термин (без скобок) -> определение
+        - stems: корень -> информация об окончании
+        """
+        self.vocabulary: dict[str, str] = {}
+        self.stems: dict[str, dict[str, str]] = {}  # корень -> информация об окончании
+        
+        with open(filepath, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        i = 0
+        len_of_lines = len(lines)
+        while i < len_of_lines:
+            line = lines[i].strip()
             
-            # Следующая непустая строка - определение
-            i += 1
-            definition = ''
-            while i < len(lines):
-                def_line = lines[i].strip()
-                # Если это не пустая строка и не заголовок
-                if def_line and not def_line.startswith('###') and not def_line.startswith('## '):
-                    definition = def_line
-                    break
+            # Пропускаем категории (##)
+            if line.startswith('## '):
                 i += 1
+                continue
             
-            # Обработка каждого термина
-            for term_raw in terms_raw:
-                if not term_raw:
-                    continue
-                
-                # Извлекаем корень (часть перед скобками) и окончание (в скобках)
-                if '[' in term_raw and ']' in term_raw:
-                    bracket_pos = term_raw.index('[')
-                    stem = term_raw[:bracket_pos]
-                    ending_info = term_raw[bracket_pos+1:term_raw.index(']')]
-                else:
-                    stem = term_raw
-                    ending_info = None
+            # Если это заголовок термина (начинается с ###)
+            if line.startswith('### '):
+                # Взять текст после ###
+                terms_line = line[4:].strip()
                 
-                # Убираем скобки - это чистый термин для поиска
-                term_clean = term_raw.replace('[', '').replace(']', '')
+                # Разбить на отдельные термины (синонимы разделены ", ")
+                terms_raw = [term.strip() for term in terms_line.split(',')]
+                assert all(term_raw for term_raw in terms_raw)
                 
-                # Добавляем в основной словарь
-                vocabulary[term_clean] = definition
+                # Следующая непустая строка - определение
+                i += 1
+                definition = ''
+                while i < len_of_lines:
+                    def_line = lines[i].strip()
+                    # Если это не пустая строка и не заголовок
+                    if def_line and not def_line.startswith('###') and not def_line.startswith('## '):
+                        definition = def_line
+                        break
+                    i += 1
                 
-                # Сохраняем информацию о корне для гибкого поиска
-                if stem and ending_info is not None:
-                    if stem.lower() not in stems:
-                        stems[stem.lower()] = {
-                            'canonical': term_clean,
-                            'ending': ending_info
-                        }
+                # Обработка каждого термина
+                for term_raw in terms_raw:
+                    self.__parse_term_raw(term_raw, definition)
+            
+            i += 1
+
+    def __parse_term_raw(self, term_raw, definition):
+        term_lemma, stem, ending = parse_term(term_raw)
+        self.vocabulary[term_lemma] = definition
         
-        i += 1
-    
-    return vocabulary, stems
+        # Сохраняем информацию о корне для гибкого поиска
+        if stem and ending is not None:
+            if stem.lower() not in self.stems:
+                self.stems[stem.lower()] = {
+                    'canonical': term_lemma,
+                    'ending': ending
+                }
 
+    def extract_stem(self, word: str):
+        """
+        Проверяет, совпадает ли слово с каким-то корнем из stems_dict
+        с допустимым окончанием (может отличаться на 0-2 буквы)
+        
+        Args:
+            word: слово для проверки (в нижнем регистре)
+        
+        Returns:
+            Канонический вид термина или None
+        """
+        for stem, info in self.stems.items():
+            if word.startswith(stem):
+                # Вычисляем окончание в слове
+                word_ending = word[len(stem):]
+                expected_ending = info['ending']
+                
+                if abs(len(word_ending) - len(expected_ending)) <= 2:
+                    return info['canonical']
+        return None
 
-def extract_stem(word, stems_dict):
-    """
-    Проверяет, совпадает ли слово с каким-то корнем из stems_dict
-    с допустимым окончанием (может отличаться на 0-2 буквы)
-    
-    Args:
-        word: слово для проверки (в нижнем регистре)
-        stems_dict: словарь корней {корень: {canonical, ending}}
-    
-    Returns:
-        Канонический вид термина или None
-    """
-    for stem, info in stems_dict.items():
-        if word.startswith(stem):
-            # Вычисляем окончание в слове
-            word_ending = word[len(stem):]
-            expected_ending = info['ending']
-            
-            if abs(len(word_ending) - len(expected_ending)) <= 2:
-                return info['canonical']
-    return None
+
+import os
+current_dir = os.path.dirname(os.path.abspath(__file__))
+vocab_file = os.path.join(current_dir, 'vocabulary.md')
+VOCABULARY_MANAGER = ParserVocabulary(vocab_file)
 
 
 if __name__ == '__main__':
-    import os
-    # Получить путь к файлу vocabulary.md в той же папке
-    current_dir = os.path.dirname(os.path.abspath(__file__))
-    vocab_file = os.path.join(current_dir, 'vocabulary.md')
-    
-    # Спарсить файл
-    vocabulary, stems = parse_vocabulary(vocab_file)
-    
-    # Вывести результаты
-    print(f"Загружено терминов: {len(vocabulary)}\n")
-    print("=== ПОЛНЫЙ СПИСОК ТЕРМИНОВ ===")
-    for term, definition in sorted(vocabulary.items()):
-        print(f"{term}: {definition[:50]}...")
-    
-    print(f"\n=== ИНФОРМАЦИЯ О КОРНЯХ ({len(stems)} корней) ===")
-    for stem, info in sorted(stems.items()):
-        print(f"{stem} [{info['ending']}] -> {info['canonical']}")
+    print(VOCABULARY_MANAGER.vocabulary)
+    print(VOCABULARY_MANAGER.stems)

vocabulary/vocabulary.md

@@ -115,13 +115,13 @@
 Троллейбусная конечная рядом с заводом цветных металлов,
 
 ## Модели автобусов и троллейбусов
-### Икарус-180
+### Икарус[]-180
 Автобус особо большого класса (с гармошкой).
 
-### Икарус-260, Икарус 260
+### Икарус[]-260, Икарус[] 260
 Автобус производства венгерской фирмы Ikarus второго поколения.
 
-### Икарус-280, Икарус 280, Икарус
+### Икарус[]-280, Икарус[] 280, Икарус[]
 Автобус особо большого класса (с гармошкой), долгое время эксплуатировавшийся в Рязани и ставший символом рязанского автобуса.
 
 ### ЛиАЗ[]-5292, ЛиАЗ[]

vocabulary/vocabulary_manager.py

@@ -1,129 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Парсер и менеджер для vocabulary.md
-Загружает категории, термины и синонимы для использования в NER и поиске.
-"""
-from pathlib import Path
-from typing import Dict, List, Tuple, Set
-
-
-class VocabularyManager:
-    """Загружает и управляет словарём из vocabulary.md"""
-    
-    def __init__(self, vocab_file: Path):
-        self.vocab_file = vocab_file
-        self.categories = {}  # {category: [(term, [synonyms]), ...]}
-        self.term_to_category = {}  # {term_lower: category}
-        self.all_terms = set()  # Все термины и синонимы
-        self.synonyms = {}  # {term_lower: canonical_term_lower}
-        
-        self._parse_vocabulary()
-    
-    def _parse_vocabulary(self):
-        """Парсит файл vocabulary.md"""
-        if not self.vocab_file.exists():
-            print(f"⚠️  Файл {self.vocab_file} не найден")
-            return
-        
-        with open(self.vocab_file, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-        
-        current_category = None
-        
-        for line in lines:
-            line = line.rstrip('\n')
-            
-            # Категория (## Название)
-            if line.startswith('## '):
-                current_category = line[3:].strip()
-                self.categories[current_category] = []
-                continue
-            
-            # Термин (### название[окончание], синоним1[окончание], синоним2, ...)
-            if line.startswith('### '):
-                if current_category is None:
-                    continue
-                
-                term_line = line[4:].strip()
-                
-                # Парсим термины и синонимы (разделены запятыми)
-                terms_raw = [t.strip() for t in term_line.split(',')]
-                
-                # Убираем квадратные скобки из всех терминов
-                terms = [term_raw.replace('[', '').replace(']', '') for term_raw in terms_raw if term_raw.strip()]
-                
-                canonical_term = terms[0]  # Первый термин - канонический
-                synonyms = terms[1:] if len(terms) > 1 else []
-                
-                # Добавляем в категорию
-                self.categories[current_category].append((canonical_term, synonyms))
-                
-                # Регистрируем все формы
-                self.term_to_category[canonical_term.lower()] = current_category
-                self.all_terms.add(canonical_term.lower())
-                
-                for synonym in synonyms:
-                    self.term_to_category[synonym.lower()] = current_category
-                    self.all_terms.add(synonym.lower())
-                    # Синонимы указывают на канонический термин
-                    self.synonyms[synonym.lower()] = canonical_term.lower()
-        
-        print(f"✓ Загружено из vocabulary.md:")
-        print(f"  - {len(self.categories)} категорий")
-        print(f"  - {sum(len(terms) for terms in self.categories.values())} термин(ов)")
-        print(f"  - {len(self.all_terms)} уникальных форм (с синонимами)")
-    
-    def get_category(self, term: str) -> str:
-        """Возвращает категорию термина или None"""
-        return self.term_to_category.get(term.lower())
-    
-    def get_canonical_form(self, term: str) -> str:
-        """Возвращает канонический вид термина (если это синоним, или сам термин)"""
-        term_lower = term.lower()
-        if term_lower in self.synonyms:
-            return self.synonyms[term_lower]
-        return term_lower
-    
-    def is_known_term(self, term: str) -> bool:
-        """Проверяет, есть ли это слово в словаре"""
-        return term.lower() in self.all_terms
-    
-    def get_all_forms(self, canonical_term: str) -> Set[str]:
-        """Возвращает все формы (синонимы) канонического термина"""
-        forms = {canonical_term.lower()}
-        for syn_form, syn_canonical in self.synonyms.items():
-            if syn_canonical == canonical_term.lower():
-                forms.add(syn_form)
-        return forms
-    
-    def get_patterns_for_spacy(self) -> List[Tuple[str, str, List[Dict]]]:
-        """
-        Возвращает паттерны для spaCy EntityRuler.
-        Формат: [(label, id, [patterns]), ...]
-        """
-        patterns = []
-        
-        for category, terms in self.categories.items():
-            # Преобразуем категорию в метку (CATEGORY)
-            label = category.upper().replace(' ', '_')
-            
-            for i, (canonical_term, synonyms) in enumerate(terms):
-                # ID = category_index
-                entity_id = f"{category.lower().replace(' ', '_')}_{i}"
-                
-                # Все формы (канонический + синонимы)
-                all_forms = [canonical_term] + synonyms
-                
-                # Создаём паттерны для каждой формы
-                entity_patterns = []
-                for form in all_forms:
-                    # Простой паттерн - точное совпадение текста
-                    entity_patterns.append({"text": form})
-                    # Вариант с разными регистрами
-                    entity_patterns.append({"text": form.lower()})
-                    if form[0].isupper():
-                        entity_patterns.append({"text": form.capitalize()})
-                
-                patterns.append((label, entity_id, entity_patterns))
-        
-        return patterns