NewStructureForProject

Dockerfile

@@ -2,8 +2,7 @@ FROM python:3.11-slim
 
 ENV PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1 HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH PORT=7860 \
-    WHISPER_MODEL=large-v3 WHISPER_COMPUTE_TYPE=int8 \
-    DATE_PARSER_MODE=natasha
+    WHISPER_MODEL=large-v3 WHISPER_COMPUTE_TYPE=int8
 
 RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg \
     && rm -rf /var/lib/apt/lists/* \
@@ -15,7 +14,8 @@ WORKDIR /home/user/app
 COPY --chown=user requirements.txt .
 RUN pip install --upgrade pip && pip install -r requirements.txt
 
-COPY --chown=user app.py natasha_dates.py ./
+COPY --chown=user app.py ./
+COPY --chown=user extractors/ ./extractors/
 
 EXPOSE 7860
 CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "4", "--timeout", "120", "app:app"]

app.py

@@ -1,39 +1,36 @@
+"""
+Voice Processing API для обработки аудио и извлечения данных о расходах.
+
+Основной файл приложения Flask.
+"""
+
 from __future__ import annotations
 
-import calendar
-import difflib
 import json
 import os
-import re
 import tempfile
-import unicodedata
-from dataclasses import dataclass
-from datetime import date, datetime, timedelta
+from datetime import date
 from pathlib import Path
 from typing import Any, Optional
 
-import iuliia
 import torch
-from dateparser.search import search_dates
 from flask import Flask, jsonify, request
-from gliner import GLiNER
-from pymorphy3 import MorphAnalyzer
-from rapidfuzz import fuzz
-from rapidfuzz.distance import Levenshtein
 from sentence_transformers import SentenceTransformer
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
 
-# Natasha - лучший парсер дат для русского языка (работает локально)
-from natasha_dates import NatashaDateExtractor, parse_date_natasha
+# Импорт экстракторов
+from extractors import (
+    ExpenseDateExtractor,
+    ExpenseSupplierExtractor,
+    ExpenseUserExtractor,
+    ExpenseAmountExtractor,
+)
+
 
 # HuggingFace Token (если нужен для моделей)
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-MORPH = MorphAnalyzer()
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 _MODEL: Optional[SentenceTransformer] = None
-_AMOUNT_MODEL: Optional[Any] = None
 _WHISPER_MODEL: Optional[Any] = None
 
 
@@ -42,6 +39,7 @@ app.config["MAX_CONTENT_LENGTH"] = 20 * 1024 * 1024
 
 
 def get_embedding_model() -> SentenceTransformer:
+    """Возвращает модель эмбеддингов (ленивая загрузка)."""
     global _MODEL
 
     if _MODEL is None:
@@ -50,16 +48,8 @@ def get_embedding_model() -> SentenceTransformer:
     return _MODEL
 
 
-def get_amount_model() -> Optional[Any]:
-    global _AMOUNT_MODEL
-
-    if _AMOUNT_MODEL is None and GLiNER is not None:
-        _AMOUNT_MODEL = GLiNER.from_pretrained("urchade/gliner_multi-v2.1")
-
-    return _AMOUNT_MODEL
-
-
 def get_whisper_model() -> Any:
+    """Возвращает модель Whisper (ленивая загрузка)."""
     global _WHISPER_MODEL
 
     if _WHISPER_MODEL is None:
@@ -72,942 +62,40 @@ def get_whisper_model() -> Any:
     return _WHISPER_MODEL
 
 
-def normalize_text(text: str) -> str:
-    text = unicodedata.normalize("NFKD", text.lower())
-    text = "".join(ch for ch in text if not unicodedata.combining(ch))
-    return re.sub(r"[^\w\s]", "", text).strip()
-
-
-def tokenize_text(text: str) -> list[str]:
-    return normalize_text(text).split()
-
-
-def lemmatize_word(word: str) -> str:
-    return MORPH.parse(word)[0].normal_form if re.fullmatch(r"[а-я]+", word) else word
-
-
-def lemmatize_text(text: str) -> list[str]:
-    return [lemmatize_word(word) for word in tokenize_text(text)]
-
-
-def variants(text: str) -> list[str]:
-    base = normalize_text(text)
-    result = [base]
-
-    for schema in (iuliia.WIKIPEDIA, iuliia.MOSMETRO, iuliia.ALA_LC):
-        try:
-            v = normalize_text(schema.translate(base))
-            if v and v not in result:
-                result.append(v)
-        except Exception:
-            pass
-
-    for v in list(result):
-        core = " ".join(w for w in v.split() if len(w) > 1 and any(ch.isalpha() for ch in w))
-        core = normalize_text(core)
-        if core and core not in result:
-            result.insert(0, core)
-
-    return result
-
-
-def token_alignment_score(phrase_variant: str, candidate_tokens: list[str]) -> float:
-    phrase_tokens = [t for t in phrase_variant.split() if len(t) > 2]
-    if not phrase_tokens or not candidate_tokens:
-        return 0.0
-    best_scores = []
-    for pt in phrase_tokens:
-        best = 0.0
-        for ct in candidate_tokens:
-            sim = Levenshtein.normalized_similarity(pt, ct)
-            if sim > best:
-                best = sim
-        best_scores.append(best)
-    return sum(best_scores) / len(best_scores)
-
-
-def length_penalty(phrase_len: int, candidate_len: int) -> float:
-    if phrase_len == 0 or candidate_len == 0:
-        return 0.0
-    ratio = min(phrase_len, candidate_len) / max(phrase_len, candidate_len)
-    if ratio >= 0.80:
-        return 1.0
-    if ratio >= 0.60:
-        return 0.90
-    if ratio >= 0.40:
-        return 0.70
-    return 0.50
-
-
-def canonicalize_for_similarity(text: str) -> str:
-    t = normalize_text(text).replace(" ", "")
-    replacements = (
-        ("sch", "sh"),
-        ("tch", "ch"),
-        ("dzh", "j"),
-        ("zh", "j"),
-        ("sh", "s"),
-        ("ch", "c"),
-        ("kh", "h"),
-        ("ph", "f"),
-        ("ck", "k"),
-        ("qu", "k"),
-        ("q", "k"),
-        ("w", "v"),
-        ("x", "ks"),
-        ("ts", "z"),
-        ("tz", "z"),
-    )
-    for src, dst in replacements:
-        t = t.replace(src, dst)
-    return re.sub(r"(.)\1+", r"\1", t)
-
-
-def phonetic_similarity(left: str, right: str) -> float:
-    l = canonicalize_for_similarity(left)
-    r = canonicalize_for_similarity(right)
-    if not l or not r:
-        return 0.0
-    char = fuzz.ratio(l, r) / 100.0
-    lev = Levenshtein.normalized_similarity(l, r)
-    return 0.50 * char + 0.50 * lev
-
-
-@dataclass(frozen=True)
-class ParsedDate:
-    date_iso: str
-    matched_expression: Optional[str]
-
-
-@dataclass(frozen=True)
-class Token:
-    original: str
-    normalized: str
-    raw_lemma: str
-    lemma: str
-    lemma_correction: Optional[str]
-    start: int
-    end: int
-    lemma_start: int
-    lemma_end: int
-
-
-WORD_RE = re.compile(r"[0-9]+(?:[./-][0-9]+)*|[а-яё]+", re.IGNORECASE)
-
-
-class UniversalDateParser:
-    MONTHS = {
-        "январь": 1, "февраль": 2, "март": 3, "апрель": 4, "май": 5, "июнь": 6,
-        "июль": 7, "август": 8, "сентябрь": 9, "октябрь": 10, "ноябрь": 11, "декабрь": 12,
-    }
-    WEEKDAYS = {
-        "понедельник": 0, "вторник": 1, "среда": 2, "четверг": 3,
-        "пятница": 4, "суббота": 5, "воскресенье": 6,
-    }
-    DIRECT_RELATIVE = {"послезавтра": 2, "позавчера": -2, "сегодня": 0, "вчера": -1, "завтра": 1}
-    ORDINAL_DAYS = {
-        "первый": 1, "второй": 2, "третий": 3, "четвертый": 4, "пятый": 5, "шестой": 6,
-        "седьмой": 7, "восьмой": 8, "девятый": 9, "десятый": 10, "одиннадцатый": 11,
-        "двенадцатый": 12, "тринадцатый": 13, "четырнадцатый": 14, "пятнадцатый": 15,
-        "шестнадцатый": 16, "семнадцатый": 17, "восемнадцатый": 18, "девятнадцатый": 19,
-        "двадцатый": 20, "двадцать первый": 21, "двадцать второй": 22, "двадцать третий": 23,
-        "двадцать четвертый": 24, "двадцать пятый": 25, "двадцать шестой": 26,
-        "двадцать седьмой": 27, "двадцать восьмой": 28, "двадцать девятый": 29,
-        "тридцатый": 30, "тридцать первый": 31,
-    }
-    NUMBER_WORDS = {
-        "ноль": 0, "один": 1, "два": 2, "три": 3, "четыре": 4, "пять": 5, "шесть": 6,
-        "семь": 7, "восемь": 8, "девять": 9, "десять": 10, "одиннадцать": 11,
-        "двенадцать": 12, "тринадцать": 13, "четырнадцать": 14, "пятнадцать": 15,
-        "шестнадцать": 16, "семнадцать": 17, "восемнадцать": 18, "девятнадцать": 19,
-        "двадцать": 20, "тридцать": 30,
-    }
-    FUTURE_HINTS = ("завтра", "послезавтра", "через", "быть", "заплатить", "следующий", "последующий")
-    PAST_HINTS = ("вчера", "позавчера", "назад", "прошлый", "предыдущий", "оплатить", "купить", "заказать")
-
-    DIRECT_RELATIVE_RE = re.compile(r"(?<!\S)(послезавтра|позавчера|сегодня|вчера|завтра)(?!\S)")
-    WEEK_RELATIVE_RE = re.compile(
-        r"(?<!\S)на (?P<which>следующий|последующий|прошлый|предыдущий|этот) неделя"
-        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)"
-    )
-    QUANTITY_RELATIVE_RE = re.compile(
-        r"(?<!\S)(?P<number>\d+|[а-яё]+(?: [а-яё]+)?) "
-        r"(?P<unit>месяц|неделя|день) "
-        r"(?P<ago>назад)"
-        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)",
-        re.IGNORECASE,
-    )
-    FORWARD_QUANTITY_RE = re.compile(
-        r"(?<!\S)(?P<through>через) "
-        r"(?P<number>\d+|[а-яё]+(?: [а-яё]+)?) "
-        r"(?P<unit>месяц|неделя|день)"
-        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)",
-        re.IGNORECASE,
-    )
-    FORWARD_SINGLE_UNIT_RE = re.compile(
-        r"(?<!\S)(?P<through>через) "
-        r"(?P<unit>месяц|неделя|день)"
-        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)",
-        re.IGNORECASE,
-    )
-    TEXTUAL_ABSOLUTE_RE = re.compile(
-        r"(?<!\S)(?P<day>\d{1,2}|[а-яё]+(?: [а-яё]+)?) "
-        r"(?P<month>январь|февраль|март|апре��ь|май|июнь|июль|август|сентябрь|октябрь|ноябрь|декабрь)"
-        r"(?: (?P<year>\d{4}))?(?!\S)",
-        re.IGNORECASE,
-    )
-    PERIOD_EDGE_RE = re.compile(
-        r"(?<!\S)(?:в )?(?P<edge>начало|конец) (?P<which>этот|следующий|последующий|прошлый|предыдущий) (?P<unit>неделя|месяц)(?!\S)",
-        re.IGNORECASE,
-    )
-
-    @classmethod
-    def temporal_vocabulary(cls) -> set[str]:
-        vocab: set[str] = set()
-        vocab.update(cls.MONTHS)
-        vocab.update(cls.WEEKDAYS)
-        vocab.update(cls.DIRECT_RELATIVE)
-        vocab.update(cls.ORDINAL_DAYS)
-        vocab.update(cls.NUMBER_WORDS)
-        vocab.update({
-            "неделя", "месяц", "день", "назад", "через", "начало", "конец", "на", "в", "во",
-            "этот", "прошлый", "предыдущий", "следующий", "последующий",
-        })
-        return vocab
-
-    @staticmethod
-    def similarity(left: str, right: str) -> float:
-        return difflib.SequenceMatcher(None, left, right).ratio()
-
-    @classmethod
-    def pick_temporal_correction(cls, normalized: str, raw_lemma: str) -> tuple[str, Optional[str]]:
-        vocab = cls.temporal_vocabulary()
-        if raw_lemma in vocab or not normalized.isalpha() or len(normalized) < 5:
-            return raw_lemma, None
-
-        candidates = list(difflib.get_close_matches(normalized, list(vocab), n=4, cutoff=0.74))
-        candidates.extend(difflib.get_close_matches(raw_lemma, list(vocab), n=4, cutoff=0.74))
-        candidates = list(dict.fromkeys(candidates))
-        if not candidates:
-            return raw_lemma, None
-
-        best = max(candidates, key=lambda item: max(cls.similarity(normalized, item), cls.similarity(raw_lemma, item)))
-        best_score = max(cls.similarity(normalized, best), cls.similarity(raw_lemma, best))
-        return (best, f"{raw_lemma}->{best}") if best_score >= 0.80 else (raw_lemma, None)
-
-    @staticmethod
-    def normalize_word(word: str) -> str:
-        return word.lower().replace("ё", "е")
-
-    @classmethod
-    def lemmatize(cls, word: str) -> str:
-        return MORPH.parse(word)[0].normal_form if word.isalpha() else word
-
-    @classmethod
-    def tokenize(cls, text: str) -> list[Token]:
-        tokens: list[Token] = []
-        lemma_cursor = 0
-
-        for match in WORD_RE.finditer(text):
-            original = match.group(0)
-            normalized = cls.normalize_word(original)
-            raw_lemma = cls.lemmatize(normalized)
-            lemma, correction = cls.pick_temporal_correction(normalized, raw_lemma)
-            lemma_start = lemma_cursor
-            lemma_end = lemma_start + len(lemma)
-            tokens.append(Token(original, normalized, raw_lemma, lemma, correction, match.start(), match.end(), lemma_start, lemma_end))
-            lemma_cursor = lemma_end + 1
-
-        return tokens
-
-    @staticmethod
-    def lemma_text(tokens: list[Token]) -> str:
-        return " ".join(token.lemma for token in tokens)
-
-    @staticmethod
-    def surface_text(text: str, tokens: list[Token], start_idx: int, end_idx: int) -> str:
-        return text[tokens[start_idx].start:tokens[end_idx].end].strip() if tokens else ""
-
-    @staticmethod
-    def lemma_span_to_token_range(tokens: list[Token], span: tuple[int, int]) -> Optional[tuple[int, int]]:
-        start_char, end_char = span
-        start_idx = end_idx = None
-
-        for idx, token in enumerate(tokens):
-            if start_idx is None and token.lemma_start <= start_char < token.lemma_end:
-                start_idx = idx
-            if token.lemma_start < end_char <= token.lemma_end:
-                end_idx = idx
-                break
-
-        return (start_idx, end_idx) if start_idx is not None and end_idx is not None else None
-
-    @classmethod
-    def make_parsed_date(cls, text: str, tokens: list[Token], match, parsed_date: date) -> Optional[ParsedDate]:
-        token_span = cls.lemma_span_to_token_range(tokens, match.span())
-        if token_span is None:
-            return None
-        return ParsedDate(parsed_date.isoformat(), cls.surface_text(text, tokens, token_span[0], token_span[1]))
-
-    @classmethod
-    def parse_number_phrase(cls, phrase: str) -> Optional[int]:
-        phrase = phrase.strip()
-        if not phrase:
-            return None
-        if phrase.isdigit():
-            return int(phrase)
-
-        parts = phrase.split()
-        if len(parts) == 1:
-            return cls.NUMBER_WORDS.get(parts[0])
-        if len(parts) == 2 and parts[0] in {"двадцать", "тридцать"}:
-            base = cls.NUMBER_WORDS.get(parts[0])
-            addon = cls.NUMBER_WORDS.get(parts[1])
-            if base is not None and addon is not None and 1 <= addon <= 9:
-                return base + addon
-        return None
-
-    @classmethod
-    def parse_day_phrase(cls, phrase: str) -> Optional[int]:
-        if phrase.isdigit():
-            value = int(phrase)
-            return value if 1 <= value <= 31 else None
-        return cls.ORDINAL_DAYS.get(phrase.strip())
-
-    @staticmethod
-    def shift_months(value: date, months: int) -> date:
-        month_index = value.month - 1 + months
-        year = value.year + month_index // 12
-        month = month_index % 12 + 1
-        day = min(value.day, calendar.monthrange(year, month)[1])
-        return date(year, month, day)
-
-    @staticmethod
-    def parse_numeric_absolute(tokens: list[Token]) -> Optional[ParsedDate]:
-        for token in tokens:
-            separator = "." if "." in token.original else "-" if "-" in token.original else "/" if "/" in token.original else None
-            if separator is None:
-                continue
-
-            parts = token.original.split(separator)
-            if len(parts) != 3 or not all(part.isdigit() for part in parts):
-                continue
-
-            try:
-                if len(parts[0]) == 4:
-                    parsed = date(int(parts[0]), int(parts[1]), int(parts[2]))
-                elif len(parts[2]) == 4:
-                    parsed = date(int(parts[2]), int(parts[1]), int(parts[0]))
-                else:
-                    continue
-                return ParsedDate(parsed.isoformat(), token.original)
-            except ValueError:
-                continue
-
-        return None
-
-    @classmethod
-    def parse_textual_absolute(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
-        lemma_text = cls.lemma_text(tokens)
-        for match in cls.TEXTUAL_ABSOLUTE_RE.finditer(lemma_text):
-            day = cls.parse_day_phrase(match.group("day"))
-            month = cls.MONTHS.get(match.group("month"))
-            if day is None or month is None:
-                continue
-
-            year = int(match.group("year")) if match.group("year") else reference_date.year
-            try:
-                parsed = date(year, month, day)
-            except ValueError:
-                continue
-
-            result = cls.make_parsed_date(text, tokens, match, parsed)
-            if result is not None:
-                return result
-
-        return None
-
-    @classmethod
-    def parse_direct_relative(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
-        lemma_text = cls.lemma_text(tokens)
-        match = cls.DIRECT_RELATIVE_RE.search(lemma_text)
-        if not match:
-            return None
-
-        parsed = reference_date + timedelta(days=cls.DIRECT_RELATIVE[match.group(1)])
-        return cls.make_parsed_date(text, tokens, match, parsed)
-
-    @staticmethod
-    def week_monday(value: date) -> date:
-        return value - timedelta(days=value.weekday())
-
-    @classmethod
-    def parse_week_relative(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
-        lemma_text = cls.lemma_text(tokens)
-        match = cls.WEEK_RELATIVE_RE.search(lemma_text)
-        if not match:
-            return None
-
-        offsets = {"следующий": 7, "последующий": 7, "прошлый": -7, "предыдущий": -7, "этот": 0}
-        anchor = reference_date + timedelta(days=offsets[match.group("which")])
-
-        if match.group("weekday"):
-            anchor = cls.week_monday(anchor) + timedelta(days=cls.WEEKDAYS[match.group("weekday")])
-
-        return cls.make_parsed_date(text, tokens, match, anchor)
-
-    @classmethod
-    def parse_period_edge(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
-        lemma_text = cls.lemma_text(tokens)
-        match = cls.PERIOD_EDGE_RE.search(lemma_text)
-        if not match:
-            return None
-
-        edge, which, unit = match.group("edge"), match.group("which"), match.group("unit")
-
-        if unit == "неделя":
-            offsets = {"прошлый": -7, "предыдущий": -7, "этот": 0, "следующий": 7, "последующий": 7}
-            monday = cls.week_monday(reference_date + timedelta(days=offsets[which]))
-            parsed_date = monday if edge == "начало" else monday + timedelta(days=6)
-        else:
-            month_offset = {"прошлый": -1, "предыдущий": -1, "этот": 0, "следующий": 1, "последующий": 1}[which]
-            shifted = cls.shift_months(date(reference_date.year, reference_date.month, 1), month_offset)
-            parsed_date = shifted if edge == "начало" else date(shifted.year, shifted.month, calendar.monthrange(shifted.year, shifted.month)[1])
-
-        return cls.make_parsed_date(text, tokens, match, parsed_date)
-
-    @classmethod
-    def parse_quantity_relative(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
-        lemma_text = cls.lemma_text(tokens)
-
-        for regex, direction in ((cls.QUANTITY_RELATIVE_RE, -1), (cls.FORWARD_QUANTITY_RE, 1)):
-            for match in regex.finditer(lemma_text):
-                number = cls.parse_number_phrase(match.group("number"))
-                if number is None:
-                    continue
-
-                unit = match.group("unit")
-                if unit == "месяц":
-                    anchor = cls.shift_months(reference_date, direction * number)
-                else:
-                    days = number * 7 if unit == "неделя" else number
-                    anchor = reference_date + timedelta(days=direction * days)
-
-                if match.group("weekday"):
-                    anchor = cls.week_monday(anchor) + timedelta(days=cls.WEEKDAYS[match.group("weekday")])
-
-                result = cls.make_parsed_date(text, tokens, match, anchor)
-                if result is not None:
-                    return result
-
-        for match in cls.FORWARD_SINGLE_UNIT_RE.finditer(lemma_text):
-            unit = match.group("unit")
-            if unit == "месяц":
-                anchor = cls.shift_months(reference_date, 1)
-            else:
-                days = 7 if unit == "неделя" else 1
-                anchor = reference_date + timedelta(days=days)
-
-            if match.group("weekday"):
-                anchor = cls.week_monday(anchor) + timedelta(days=cls.WEEKDAYS[match.group("weekday")])
-
-            result = cls.make_parsed_date(text, tokens, match, anchor)
-            if result is not None:
-                return result
-
-        return None
-
-    @classmethod
-    def preference_for_text(cls, tokens: list[Token]) -> str:
-        lemmas = [token.lemma for token in tokens]
-        future = sum(1 for hint in cls.FUTURE_HINTS if hint in lemmas)
-        past = sum(1 for hint in cls.PAST_HINTS if hint in lemmas)
-        return "future" if future > past else "past"
-
-    @staticmethod
-    def choose_best(matches: list[tuple[str, datetime]]) -> tuple[str, datetime]:
-        return sorted(matches, key=lambda item: (len(item[0]), -item[1].timestamp()), reverse=True)[0]
-
-    def parse(self, text: str, reference_date: date) -> Optional[ParsedDate]:
-        tokens = self.tokenize(text)
-
-        for parser in (
-            lambda: self.parse_numeric_absolute(tokens),
-            lambda: self.parse_textual_absolute(text, tokens, reference_date),
-            lambda: self.parse_direct_relative(text, tokens, reference_date),
-            lambda: self.parse_week_relative(text, tokens, reference_date),
-            lambda: self.parse_period_edge(text, tokens, reference_date),
-            lambda: self.parse_quantity_relative(text, tokens, reference_date),
-        ):
-            parsed = parser()
-            if parsed is not None:
-                return parsed
-
-        normalized = " ".join(token.normalized for token in tokens)
-        relative_base = datetime.combine(reference_date, datetime.min.time()).replace(hour=12)
-        result = search_dates(
-            normalized,
-            languages=["ru"],
-            settings={
-                "RELATIVE_BASE": relative_base,
-                "PREFER_DATES_FROM": self.preference_for_text(tokens),
-                "STRICT_PARSING": False,
-                "REQUIRE_PARTS": [],
-                "NORMALIZE": True,
-                "RETURN_AS_TIMEZONE_AWARE": False,
-                "DATE_ORDER": "DMY",
-            },
-        )
-
-        filtered: list[tuple[str, datetime]] = []
-        for matched, value in result or []:
-            if isinstance(value, datetime) and not matched.strip().isdigit() and 2020 <= value.year <= 2100:
-                filtered.append((matched.strip(), value))
-
-        if not filtered:
-            return None
-
-        matched_expression, value = self.choose_best(filtered)
-        return ParsedDate(date_iso=value.date().isoformat(), matched_expression=matched_expression)
-
-
-class ExpenseDateExtractor:
-    def __init__(self) -> None:
-        self.parser = UniversalDateParser()
-
-    def extract(self, text: str, reference_date: str | date | None = None) -> dict[str, Any]:
-        ref_date = self.to_date(reference_date or date.today().isoformat())
-        parsed = self.parser.parse(text=text, reference_date=ref_date)
-
-        return {
-            "date": datetime.strptime(parsed.date_iso, "%Y-%m-%d").strftime("%d.%m.%Y") if parsed else None,
-            "date_iso": parsed.date_iso if parsed else None,
-            "matched_date_phrase": parsed.matched_expression if parsed else None,
-        }
-
-    @staticmethod
-    def to_date(value: str | date) -> date:
-        return value if isinstance(value, date) else datetime.strptime(value, "%Y-%m-%d").date()
-
-
-# Парсер дат: "natasha" (рекомендуется) или "legacy"
-DATE_PARSER_MODE = os.getenv("DATE_PARSER_MODE", "legacy")
-
-def get_date_extractor():
+class ExpenseTextExtractor:
     """
-    Возвращает экстрактор дат.
-    - natasha: Лучший для русского языка (по умолчанию)
-    - legacy: Старый код ExpenseDateExtractor
+    Главный экстрактор данных о расходах.
+    
+    Комбинирует все ��кстракторы: даты, поставщики, пользователи, суммы.
     """
-    if DATE_PARSER_MODE == "natasha":
-        return NatashaDateExtractor()
-    return ExpenseDateExtractor()
-
-
-class ExpenseUserExtractor:
-    def __init__(self, users: list[str], suppliers: list[str], model: SentenceTransformer, threshold: float = 0.6) -> None:
-        self.users = users
-        self.model = model
-        self.threshold = threshold
-        self.supplier_terms = {normalize_text(supplier) for supplier in suppliers}
-        self.user_terms = [normalize_text(user) for user in users]
-        self.user_embeddings = model.encode(
-            [f"passage: {user}" for user in self.user_terms],
-            convert_to_tensor=True,
-            normalize_embeddings=True,
-        )
-
-    def extract(self, text: str, supplier_phrase: str | None = None, date_phrase: str | None = None) -> dict[str, Any]:
-        excluded_tokens: set[str] = set()
-        if supplier_phrase:
-            excluded_tokens.update(normalize_text(supplier_phrase).split())
-        if date_phrase:
-            excluded_tokens.update(normalize_text(date_phrase).split())
-
-        best_user = None
-        best_score = -1.0
-        best_phrase = None
-
-        for word in lemmatize_text(text):
-            if len(word) < 3:
-                continue
-            if word in excluded_tokens or word in self.supplier_terms:
-                continue
-
-            query_emb = self.model.encode(
-                f"query: {word}",
-                convert_to_tensor=True,
-                normalize_embeddings=True,
-            )
-            similarities = torch.cosine_similarity(query_emb.unsqueeze(0), self.user_embeddings, dim=1)
-            idx = int(torch.argmax(similarities))
-            score = similarities[idx].item()
-
-            if score > best_score:
-                best_score = score
-                best_user = self.users[idx]
-                best_phrase = word
-
-        if best_score >= self.threshold:
-            return {
-                "user": best_user,
-                "user_score": round(best_score, 4),
-                "matched_user_phrase": best_phrase,
-            }
-
-        if re.search(r"(?<!\S)я(?!\S)", normalize_text(text), re.IGNORECASE):
-            return {
-                "user": "Я",
-                "user_score": 1.0,
-                "matched_user_phrase": "я",
-            }
-
-        return {
-            "user": None,
-            "user_score": None,
-            "matched_user_phrase": None,
-        }
-
-
-class ExpenseSupplierExtractor:
-    def __init__(self, suppliers: list[str]) -> None:
-        self.suppliers = suppliers
-        self.sup_norm = [normalize_text(s) for s in suppliers]
-        self.sup_tokens = [s.split() for s in self.sup_norm]
-        self.sup_num_sets = [self.numeric_tokens(s) for s in self.sup_norm]
-        self.sup_number_tokens = {token for supplier in self.sup_tokens for token in supplier if token.isdigit()}
-        self.supplier_lexicon = [
-            token
-            for token in sorted({tok for tokens in self.sup_tokens for tok in tokens})
-            if token and not token.isdigit()
-        ]
-        self.tfidf = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5))
-        self.sup_mat = self.tfidf.fit_transform(self.sup_norm)
-        self.max_words = max(len(s.split()) for s in self.sup_norm)
-        self.variant_cache: dict[str, list[str]] = {}
-        self.lexical_token_cache: dict[str, float] = {}
-        self.phrase_support_cache: dict[str, float] = {}
-        self.noise_terms = {
-            "за", "на", "из", "для", "под", "над", "при", "без", "и", "или",
-            "купил", "купила", "купили", "покупка", "заказал", "заказала", "заказали",
-            "оплатил", "оплатила", "оплатили", "заплатил", "заплатила", "заплатили",
-            "был", "была", "было", "были", "утром", "днем", "днём", "вечером", "ночью",
-            "товар", "товары", "продукт", "продукты", "десерт", "еда",
-            "лей", "лея", "леи", "целых", "сотых", "сом", "сомов", "руб", "рублей", "грн", "usd", "eur",
-        }
-        self.noise_terms.update(UniversalDateParser.temporal_vocabulary())
-
-    @staticmethod
-    def numeric_tokens(text: str) -> set[str]:
-        return set(re.findall(r"\d+", text))
-
-    def cached_variants(self, text: str) -> list[str]:
-        key = normalize_text(text)
-        cached = self.variant_cache.get(key)
-        if cached is None:
-            cached = variants(key)
-            self.variant_cache[key] = cached
-        return cached
-
-    @staticmethod
-    def split_words(text: str) -> list[str]:
-        return [w for w in normalize_text(text).split() if w]
-
-    @classmethod
-    def is_supplier_extension(cls, base_supplier: str, extended_supplier: str) -> bool:
-        base_tokens = cls.split_words(base_supplier)
-        extended_tokens = cls.split_words(extended_supplier)
-        return len(base_tokens) < len(extended_tokens) and extended_tokens[:len(base_tokens)] == base_tokens
-
-    @classmethod
-    def phrase_token_count(cls, phrase: str | None) -> int:
-        return len(cls.split_words(phrase or ""))
-
-    @classmethod
-    def resolve_overlapping_suppliers(cls, ranking: list[dict[str, Any]]) -> dict[str, Any]:
-        if not ranking:
-            return {"supplier": None, "score": -1.0, "phrase": None}
-
-        best = ranking[0]
-        best_combined = float(best.get("combined", best.get("score", -1.0)))
-        best_phrase_len = cls.phrase_token_count(best.get("phrase"))
-
-        for alt in ranking[1:]:
-            if not cls.is_supplier_extension(str(best.get("supplier") or ""), str(alt.get("supplier") or "")):
-                continue
-
-            alt_combined = float(alt.get("combined", alt.get("score", -1.0)))
-            alt_phrase_len = cls.phrase_token_count(alt.get("phrase"))
-
-            if alt_phrase_len > best_phrase_len and alt_combined >= best_combined - 0.15:
-                best = alt
-                best_combined = alt_combined
-                best_phrase_len = alt_phrase_len
-
-        return best
-
-    @staticmethod
-    def numeric_compatibility_multiplier(phrase_nums: set[str], candidate_nums: set[str]) -> float:
-        if not phrase_nums and not candidate_nums:
-            return 1.0
-        if phrase_nums == candidate_nums:
-            return 1.08
-        if phrase_nums and candidate_nums:
-            return 1.03 if phrase_nums & candidate_nums else 0.80
-        return 0.82
-
-    def lexical_support(self, phrase: str) -> float:
-        tokens = [token for token in normalize_text(phrase).split() if token and not token.isdigit()]
-        if not tokens or not self.supplier_lexicon:
-            return 0.0
-
-        support_scores: list[float] = []
-        for token in tokens:
-            cached = self.lexical_token_cache.get(token)
-            if cached is not None:
-                support_scores.append(cached)
-                continue
-
-            best = 0.0
-            for token_variant in self.cached_variants(token):
-                for lex in self.supplier_lexicon:
-                    lev = Levenshtein.normalized_similarity(token_variant, lex)
-                    phon = phonetic_similarity(token_variant, lex)
-                    sim = max(lev, phon)
-                    if sim > best:
-                        best = sim
-
-            self.lexical_token_cache[token] = best
-            support_scores.append(best)
-
-        return sum(support_scores) / len(support_scores)
-
-    def score_phrase(self, phrase: str) -> dict[str, Any]:
-        vs = self.cached_variants(phrase)
-        q = self.tfidf.transform(vs)
-        tf = cosine_similarity(q, self.sup_mat)
-
-        best: dict[str, Any] = {"supplier": None, "score": -1.0, "phrase": phrase, "variant": ""}
-        for i, cand in enumerate(self.sup_norm):
-            local = -1.0
-            local_variant = ""
-            candidate_nums = self.sup_num_sets[i]
-            for j, v in enumerate(vs):
-                char = fuzz.ratio(v, cand) / 100.0
-                tf_val = float(tf[j, i])
-                penalty = length_penalty(len(v), len(cand))
-                phon = phonetic_similarity(v, cand)
-                phrase_nums = self.numeric_tokens(v)
-
-                if len(v.split()) == 1 and len(cand.split()) == 1:
-                    lev = Levenshtein.normalized_similarity(v, cand)
-                    val = (0.45 * lev + 0.25 * char + 0.10 * tf_val + 0.20 * phon) * penalty
-                else:
-                    align = token_alignment_score(v, self.sup_tokens[i])
-                    tok = fuzz.token_set_ratio(v, cand) / 100.0
-                    val = (0.30 * char + 0.20 * tok + 0.10 * tf_val + 0.20 * align + 0.20 * phon) * penalty
-
-                    compact_v = v.replace(" ", "")
-                    compact_cand = cand.replace(" ", "")
-                    compact_char = fuzz.ratio(compact_v, compact_cand) / 100.0
-                    compact_lev = Levenshtein.normalized_similarity(compact_v, compact_cand)
-                    compact_phon = phonetic_similarity(compact_v, compact_cand)
-                    compact = max(compact_char, compact_lev, compact_phon)
-                    if compact > 0.55:
-                        val = max(val, compact * penalty)
-
-                val *= self.numeric_compatibility_multiplier(phrase_nums, candidate_nums)
-
-                if val > local:
-                    local = val
-                    local_variant = v
-
-            if local > best["score"]:
-                best = {"supplier": self.suppliers[i], "score": local, "phrase": phrase, "variant": local_variant}
-        return best
-
-    def extract(self, text: str, date_phrase: str | None = None, debug: bool = False) -> dict[str, Any]:
-        threshold = 0.50
-        excluded_tokens: set[str] = set()
-        if date_phrase:
-            excluded_tokens.update(normalize_text(date_phrase).split())
-        excluded_tokens.update(self.noise_terms)
-
-        raw_tokens = normalize_text(text).split()
-        tokens: list[str] = []
-        for token in raw_tokens:
-            if token in excluded_tokens:
-                continue
-
-            if token.isdigit():
-                if token in self.sup_number_tokens:
-                    tokens.append(token)
-
-                if tokens and len(token) <= 3 and len(tokens[-1]) >= 4 and tokens[-1].isalpha():
-                    tokens.append(f"{tokens[-1]}{token}")
-                continue
-
-            if len(token) > 1:
-                tokens.append(token)
-
-        tokens = [t for t in tokens if len(t) > 1 and t not in excluded_tokens]
-
-        phrases: list[str] = []
-        seen: set[str] = set()
-        for i in range(len(tokens)):
-            for j in range(i + 1, min(i + 1 + self.max_words, len(tokens) + 1)):
-                p = " ".join(tokens[i:j])
-                if p not in seen:
-                    seen.add(p)
-                    phrases.append(p)
-
-        results = [self.score_phrase(p) for p in phrases]
-        candidate_rows: list[dict[str, Any]] = []
-        best_by_supplier: dict[str, dict[str, Any]] = {}
-        for row in results:
-            supplier = row["supplier"]
-            score = float(row.get("score", -1.0))
-            phrase = str(row.get("phrase") or "")
-            support = self.phrase_support_cache.get(phrase)
-            if support is None:
-                support = self.lexical_support(phrase)
-                self.phrase_support_cache[phrase] = support
-            combined = 0.75 * score + 0.25 * support
-
-            if debug:
-                candidate_rows.append({
-                    "supplier": supplier,
-                    "phrase": phrase,
-                    "score": round(score, 4),
-                    "support": round(support, 4),
-                    "combined": round(combined, 4),
-                })
-
-            enriched = {**row, "combined": combined}
-            passes = score >= threshold or combined >= 0.48
-            if passes and (supplier not in best_by_supplier or combined > float(best_by_supplier[supplier].get("combined", -1.0))):
-                best_by_supplier[supplier] = enriched
-
-        if not best_by_supplier and results:
-            def support_for_phrase(phrase: str) -> float:
-                cached_support = self.phrase_support_cache.get(phrase)
-                if cached_support is None:
-                    cached_support = self.lexical_support(phrase)
-                    self.phrase_support_cache[phrase] = cached_support
-                return cached_support
-
-            fallback = max(
-                results,
-                key=lambda item: 0.75 * float(item.get("score", -1.0)) + 0.25 * support_for_phrase(str(item.get("phrase") or "")),
-            )
-            fallback_score = float(fallback.get("score", -1.0))
-            fallback_phrase = str(fallback.get("phrase") or "")
-            fallback_support = support_for_phrase(fallback_phrase)
-            fallback_combined = 0.75 * fallback_score + 0.25 * fallback_support
-            if fallback_score >= 0.40 and fallback_support >= 0.43 and fallback_combined >= 0.43:
-                best_by_supplier[fallback["supplier"]] = {**fallback, "combined": fallback_combined}
-
-        supplier_ranking = sorted(best_by_supplier.values(), key=lambda x: float(x.get("combined", x["score"])), reverse=True)
-        best = self.resolve_overlapping_suppliers(supplier_ranking)
-
-        payload = {
-            "supplier": best["supplier"],
-            "supplier_score": round(best["score"], 4) if best["score"] >= 0 else None,
-            "matched_supplier_phrase": best.get("phrase"),
-        }
-
-        if debug:
-            top_candidates = sorted(candidate_rows, key=lambda item: item["combined"], reverse=True)[:8]
-            payload["supplier_debug"] = {
-                "tokens": tokens,
-                "phrases_count": len(phrases),
-                "top_candidates": top_candidates,
-            }
-
-        return payload
-
-
-class ExpenseAmountExtractor:
-    def __init__(self, suppliers: list[str]) -> None:
-        self.model = get_amount_model()
-
-    @staticmethod
-    def to_float(value: str) -> Optional[float]:
-        cleaned = value.replace(" ", "").replace("\u00A0", "")
-        match = re.search(r"\d+(?:[,]\d{1,2})?", cleaned)
-        if not match:
-            return None
-        try:
-            return float(match.group(0).replace(",", "."))
-        except ValueError:
-            return None
-
-    @staticmethod
-    def phrase_span(text: str, phrase: Optional[str]) -> Optional[tuple[int, int]]:
-        if not phrase:
-            return None
-        idx = text.lower().find(phrase.lower())
-        if idx == -1:
-            return None
-        return idx, idx + len(phrase)
-
-    @staticmethod
-    def overlaps(span1: tuple[int, int], span2: Optional[tuple[int, int]]) -> bool:
-        if span2 is None:
-            return False
-        return span1[0] < span2[1] and span2[0] < span1[1]
-
-    @staticmethod
-    def expand_amount_text(text: str, start: int, end: int) -> tuple[str, tuple[int, int]]:
-        suffix = re.match(r",\d{1,2}", text[end:])
-        if suffix:
-            new_end = end + len(suffix.group(0))
-            return text[start:new_end].strip(), (start, new_end)
-
-        prefix = re.search(r"(\d{1,3}(?:\s*\d{3})*),", text[:start])
-        if prefix:
-            new_start = prefix.start(1)
-            return text[new_start:end].strip(), (new_start, end)
-
-        return text[start:end].strip(), (start, end)
-
-    def extract(
-        self,
-        text: str,
-        matched_date_phrase: Optional[str] = None,
-        matched_supplier_phrase: Optional[str] = None,
-    ) -> dict[str, Any]:
-        if self.model is None:
-            return {"amount": None, "amount_text": None}
-
-        date_span = self.phrase_span(text, matched_date_phrase)
-        supplier_span = self.phrase_span(text, matched_supplier_phrase)
-        entities = self.model.predict_entities(text, ["money"], threshold=0.3)
-
-        for ent in sorted(entities, key=lambda item: float(item.get("score", 0.0)), reverse=True):
-            raw_span = (int(ent.get("start", 0)), int(ent.get("end", 0)))
-            amount_text, span = self.expand_amount_text(text, raw_span[0], raw_span[1])
-            amount = self.to_float(amount_text)
-            overlaps_date = self.overlaps(span, date_span)
-            overlaps_supplier = self.overlaps(span, supplier_span)
-
-            if amount is None:
-                continue
-            if overlaps_date or overlaps_supplier:
-                continue
-            return {"amount": amount, "amount_text": amount_text}
-
-        return {"amount": None, "amount_text": None}
-
-
-class ExpenseTextExtractor:
+    
     def __init__(self, suppliers: list[str], users: list[str]) -> None:
         self.date_extractor = ExpenseDateExtractor()
         self.supplier_extractor = ExpenseSupplierExtractor(suppliers=suppliers)
         self.amount_extractor = ExpenseAmountExtractor(suppliers=suppliers)
-        self.user_extractor = ExpenseUserExtractor(users=users, suppliers=suppliers, model=get_embedding_model())
+        self.user_extractor = ExpenseUserExtractor(
+            users=users, 
+            suppliers=suppliers, 
+            model=get_embedding_model()
+        )
 
-    def extract(self, text: str, reference_date: str | date | None = None, debug_supplier: bool = False) -> dict[str, Any]:
+    def extract(
+        self, 
+        text: str, 
+        reference_date: str | date | None = None, 
+        debug_supplier: bool = False
+    ) -> dict[str, Any]:
+        """
+        Извлекает все данные из текста.
+        
+        Args:
+            text: Текст для анализа
+            reference_date: Базовая дата
+            debug_supplier: Включить отладку поставщиков
+            
+        Returns:
+            Словарь со всеми извлечёнными данными
+        """
         date_info = self.date_extractor.extract(text, reference_date=reference_date)
         supplier_info = self.supplier_extractor.extract(
             text,
@@ -1039,10 +127,12 @@ class ExpenseTextExtractor:
 
 
 def build_default_pipeline(suppliers: list[str], users: list[str]) -> ExpenseTextExtractor:
+    """Создаёт пайплайн извлечения данных."""
     return ExpenseTextExtractor(suppliers=suppliers, users=users)
 
 
 def extract_names(items: Any) -> list[str]:
+    """Извлекает имена из списка объектов или строк."""
     if not isinstance(items, list):
         return []
 
@@ -1061,6 +151,8 @@ def extract_names(items: Any) -> list[str]:
 
 
 def polish_notes_text(text: str) -> str:
+    """Форматирует текст заметки."""
+    import re
     normalized = re.sub(r"\s+", " ", text).strip()
     if not normalized:
         return ""
@@ -1073,6 +165,7 @@ def polish_notes_text(text: str) -> str:
 
 
 def transcribe_audio_text(audio_path: str) -> str:
+    """Транскрибирует аудио в текст."""
     mock_text = os.getenv("EXPENSE_VOICE_MOCK_TEXT")
     if mock_text:
         return mock_text.strip()
@@ -1090,6 +183,7 @@ def transcribe_audio_text(audio_path: str) -> str:
 
 
 def process_voice_request(audio_path: str, mode: str, payload: dict[str, Any]) -> dict[str, Any]:
+    """Обрабатывает голосовой запрос."""
     context = payload.get("context", {}) if isinstance(payload, dict) else {}
     supplier_names = extract_names(context.get("suppliers"))
     user_names = extract_names(context.get("users"))
@@ -1129,6 +223,7 @@ def process_voice_request(audio_path: str, mode: str, payload: dict[str, Any]) -
 
 
 def require_auth():
+    """Проверяет авторизацию запроса."""
     expected_token = os.getenv("PYTHON_API_TOKEN", os.getenv("EXPENSE_VOICE_FASTAPI_TOKEN", "")).strip()
 
     if not expected_token:
@@ -1146,6 +241,7 @@ def require_auth():
 
 
 def parse_context(raw: str | None) -> dict[str, Any]:
+    """Парсит JSON контекст."""
     if not raw:
         return {}
 
@@ -1156,12 +252,16 @@ def parse_context(raw: str | None) -> dict[str, Any]:
         return {}
 
 
+# ============================================================================
+# ENDPOINTS
+# ============================================================================
+
 @app.get("/")
 def index():
+    """Главная страница API."""
     return jsonify({
         "status": "ok",
         "message": "Voice processing API is running",
-        "date_parser": DATE_PARSER_MODE,
         "endpoints": {
             "POST /process-audio": "Process audio file",
             "GET /health": "Health check",
@@ -1172,12 +272,13 @@ def index():
 
 @app.get("/health")
 def health():
+    """Проверка здоровья сервиса."""
     return jsonify({"status": "ok"})
 
 
 @app.get("/date-test")
 def date_test():
-    """Тестирование парсера дат (использует текущий DATE_PARSER_MODE)."""
+    """Тестирование парсера дат."""
     test_phrases = [
         "завтра",
         "через 2 дня",
@@ -1191,7 +292,7 @@ def date_test():
         "в конце месяца"
     ]
     
-    extractor = get_date_extractor()
+    extractor = ExpenseDateExtractor()
     results = []
     for phrase in test_phrases:
         result = extractor.extract(phrase)
@@ -1203,7 +304,6 @@ def date_test():
     
     return jsonify({
         "status": "ok",
-        "parser": DATE_PARSER_MODE,
         "reference_date": date.today().isoformat(),
         "results": results
     })
@@ -1211,6 +311,7 @@ def date_test():
 
 @app.post("/process-audio")
 def process_audio():
+    """Обработка аудио файла."""
     auth_error = require_auth()
     if auth_error:
         return auth_error
@@ -1240,4 +341,4 @@ def process_audio():
 
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=int(os.getenv("PORT", "7860")))
+    app.run(host="0.0.0.0", port=int(os.getenv("PORT", "7860")))

extractors/__init__.py

@@ -0,0 +1,21 @@
+"""
+Модуль экстракторов данных из текста.
+
+- DateExtractor: извлечение дат
+- SupplierExtractor: извлечение поставщиков  
+- UserExtractor: извлечение пользователей
+- AmountExtractor: извлечение сумм
+"""
+
+from extractors.date_extractor import ExpenseDateExtractor, ParsedDate
+from extractors.supplier_extractor import ExpenseSupplierExtractor
+from extractors.user_extractor import ExpenseUserExtractor
+from extractors.amount_extractor import ExpenseAmountExtractor
+
+__all__ = [
+    "ExpenseDateExtractor",
+    "ExpenseSupplierExtractor", 
+    "ExpenseUserExtractor",
+    "ExpenseAmountExtractor",
+    "ParsedDate",
+]

extractors/amount_extractor.py

@@ -0,0 +1,124 @@
+"""
+Экстрактор сумм из текста.
+
+Использует GLiNER для извлечения денежных сумм.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Optional
+
+from gliner import GLiNER
+
+
+# Глобальная модель для извлечения сумм
+_AMOUNT_MODEL: Optional[GLiNER] = None
+
+
+def get_amount_model() -> Optional[GLiNER]:
+    """Возвращает модель для извлечения сумм (ленивая загрузка)."""
+    global _AMOUNT_MODEL
+
+    if _AMOUNT_MODEL is None:
+        _AMOUNT_MODEL = GLiNER.from_pretrained("urchade/gliner_multi-v2.1")
+
+    return _AMOUNT_MODEL
+
+
+class ExpenseAmountExtractor:
+    """
+    Экстрактор денежных сумм из текста.
+    
+    Использует GLiNER для поиска упоминаний денег.
+    """
+    
+    def __init__(self, suppliers: list[str] | None = None) -> None:
+        """
+        Args:
+            suppliers: Список поставщиков (не используется, для совместимости)
+        """
+        self.model = get_amount_model()
+
+    @staticmethod
+    def to_float(value: str) -> Optional[float]:
+        """Преобразует строку в число."""
+        cleaned = value.replace(" ", "").replace("\u00A0", "")
+        match = re.search(r"\d+(?:[,]\d{1,2})?", cleaned)
+        if not match:
+            return None
+        try:
+            return float(match.group(0).replace(",", "."))
+        except ValueError:
+            return None
+
+    @staticmethod
+    def phrase_span(text: str, phrase: Optional[str]) -> Optional[tuple[int, int]]:
+        """Возвращает позицию фразы в тексте."""
+        if not phrase:
+            return None
+        idx = text.lower().find(phrase.lower())
+        if idx == -1:
+            return None
+        return idx, idx + len(phrase)
+
+    @staticmethod
+    def overlaps(span1: tuple[int, int], span2: Optional[tuple[int, int]]) -> bool:
+        """Проверяет пересечение двух диапазонов."""
+        if span2 is None:
+            return False
+        return span1[0] < span2[1] and span2[0] < span1[1]
+
+    @staticmethod
+    def expand_amount_text(text: str, start: int, end: int) -> tuple[str, tuple[int, int]]:
+        """Расширяет текст суммы (для дробных чисел)."""
+        suffix = re.match(r",\d{1,2}", text[end:])
+        if suffix:
+            new_end = end + len(suffix.group(0))
+            return text[start:new_end].strip(), (start, new_end)
+
+        prefix = re.search(r"(\d{1,3}(?:\s*\d{3})*),", text[:start])
+        if prefix:
+            new_start = prefix.start(1)
+            return text[new_start:end].strip(), (new_start, end)
+
+        return text[start:end].strip(), (start, end)
+
+    def extract(
+        self,
+        text: str,
+        matched_date_phrase: Optional[str] = None,
+        matched_supplier_phrase: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """
+        Извлекает сумму из текста.
+        
+        Args:
+            text: Текст для анализа
+            matched_date_phrase: Фраза даты для исключения
+            matched_supplier_phrase: Фраза поставщика для исключения
+            
+        Returns:
+            Словарь с amount и amount_text
+        """
+        if self.model is None:
+            return {"amount": None, "amount_text": None}
+
+        date_span = self.phrase_span(text, matched_date_phrase)
+        supplier_span = self.phrase_span(text, matched_supplier_phrase)
+        entities = self.model.predict_entities(text, ["money"], threshold=0.3)
+
+        for ent in sorted(entities, key=lambda item: float(item.get("score", 0.0)), reverse=True):
+            raw_span = (int(ent.get("start", 0)), int(ent.get("end", 0)))
+            amount_text, span = self.expand_amount_text(text, raw_span[0], raw_span[1])
+            amount = self.to_float(amount_text)
+            overlaps_date = self.overlaps(span, date_span)
+            overlaps_supplier = self.overlaps(span, supplier_span)
+
+            if amount is None:
+                continue
+            if overlaps_date or overlaps_supplier:
+                continue
+            return {"amount": amount, "amount_text": amount_text}
+
+        return {"amount": None, "amount_text": None}

extractors/date_extractor.py

@@ -0,0 +1,518 @@
+"""
+Экстрактор дат из русского текста.
+
+Классы:
+- UniversalDateParser: парсер дат с поддержкой относительных и абсолютных дат
+- ExpenseDateExtractor: обёртка для извлечения дат из текста
+- ParsedDate: результат парсинга
+- Token: токен текста
+"""
+
+from __future__ import annotations
+
+import calendar
+import difflib
+import re
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+from typing import Any, Optional
+
+from dateparser.search import search_dates
+from pymorphy3 import MorphAnalyzer
+
+
+MORPH = MorphAnalyzer()
+WORD_RE = re.compile(r"[0-9]+(?:[./-][0-9]+)*|[а-яё]+", re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class ParsedDate:
+    """Результат парсинга даты."""
+    date_iso: str
+    matched_expression: Optional[str]
+
+
+@dataclass(frozen=True)
+class Token:
+    """Токен текста с морфологической информацией."""
+    original: str
+    normalized: str
+    raw_lemma: str
+    lemma: str
+    lemma_correction: Optional[str]
+    start: int
+    end: int
+    lemma_start: int
+    lemma_end: int
+
+
+class UniversalDateParser:
+    """
+    Универсальный парсер дат для русского языка.
+    
+    Поддерживает:
+    - Прямые относительные даты: вчера, завтра, позавчера, послезавтра
+    - Недели: на следующей неделе, на прошлой неделе
+    - Периоды: через 2 дня, 3 недели назад, через месяц
+    - Текстовые даты: 5 марта, 15 января 2025
+    - Числовые даты: 15.01.2025, 2025-01-15
+    - Края периодов: в конце месяца, в начале недели
+    """
+    
+    MONTHS = {
+        "январь": 1, "февраль": 2, "март": 3, "апрель": 4, "май": 5, "июнь": 6,
+        "июль": 7, "август": 8, "сентябрь": 9, "октябрь": 10, "ноябрь": 11, "декабрь": 12,
+    }
+    
+    WEEKDAYS = {
+        "понедельник": 0, "вторник": 1, "среда": 2, "четверг": 3,
+        "пятница": 4, "суббота": 5, "воскресенье": 6,
+    }
+    
+    DIRECT_RELATIVE = {
+        "послезавтра": 2, "позавчера": -2, "сегодня": 0, "вчера": -1, "завтра": 1
+    }
+    
+    ORDINAL_DAYS = {
+        "первый": 1, "второй": 2, "третий": 3, "четвертый": 4, "пятый": 5, "шестой": 6,
+        "седьмой": 7, "восьмой": 8, "девятый": 9, "десятый": 10, "одиннадцатый": 11,
+        "двенадцатый": 12, "тринадцатый": 13, "четырнадцатый": 14, "пятнадцатый": 15,
+        "шестнадцатый": 16, "семнадцатый": 17, "восемнадцатый": 18, "девятнадцатый": 19,
+        "двадцатый": 20, "двадцать первый": 21, "двадцать второй": 22, "двадцать третий": 23,
+        "двадцать четвертый": 24, "двадцать пятый": 25, "двадцать шестой": 26,
+        "двадцать седьмой": 27, "двадцать восьмой": 28, "двадцать девятый": 29,
+        "тридцатый": 30, "тридцать первый": 31,
+    }
+    
+    NUMBER_WORDS = {
+        "ноль": 0, "один": 1, "два": 2, "три": 3, "четыре": 4, "пять": 5, "шесть": 6,
+        "семь": 7, "восемь": 8, "девять": 9, "десять": 10, "одиннадцать": 11,
+        "двенадцать": 12, "тринадцать": 13, "четырнадцать": 14, "пятнадцать": 15,
+        "шестнадцать": 16, "семнадцать": 17, "восемнадцать": 18, "девятнадцать": 19,
+        "двадцать": 20, "тридцать": 30,
+    }
+    
+    FUTURE_HINTS = ("завтра", "послезавтра", "через", "быть", "заплатить", "следующий", "последующий")
+    PAST_HINTS = ("вчера", "позавчера", "назад", "прошлый", "предыдущий", "оплатить", "купить", "заказать")
+
+    # Регулярные выражения для парсинга
+    DIRECT_RELATIVE_RE = re.compile(r"(?<!\S)(послезавтра|позавчера|сегодня|вчера|завтра)(?!\S)")
+    
+    WEEK_RELATIVE_RE = re.compile(
+        r"(?<!\S)на (?P<which>следующий|последующий|прошлый|предыдущий|этот) неделя"
+        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)"
+    )
+    
+    QUANTITY_RELATIVE_RE = re.compile(
+        r"(?<!\S)(?P<number>\d+|[а-яё]+(?: [а-яё]+)?) "
+        r"(?P<unit>месяц|неделя|день) "
+        r"(?P<ago>назад)"
+        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)",
+        re.IGNORECASE,
+    )
+    
+    FORWARD_QUANTITY_RE = re.compile(
+        r"(?<!\S)(?P<through>через) "
+        r"(?P<number>\d+|[а-яё]+(?: [а-яё]+)?) "
+        r"(?P<unit>месяц|неделя|день)"
+        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)",
+        re.IGNORECASE,
+    )
+    
+    FORWARD_SINGLE_UNIT_RE = re.compile(
+        r"(?<!\S)(?P<through>через) "
+        r"(?P<unit>месяц|неделя|день)"
+        r"(?: (?P<prep>в|во|на) (?P<weekday>понедельник|вторник|среда|четверг|пятница|суббота|воскресенье))?(?!\S)",
+        re.IGNORECASE,
+    )
+    
+    TEXTUAL_ABSOLUTE_RE = re.compile(
+        r"(?<!\S)(?P<day>\d{1,2}|[а-яё]+(?: [а-яё]+)?) "
+        r"(?P<month>январь|февраль|март|апрель|май|июнь|июль|август|сентябрь|октябрь|ноябрь|декабрь)"
+        r"(?: (?P<year>\d{4}))?(?!\S)",
+        re.IGNORECASE,
+    )
+    
+    PERIOD_EDGE_RE = re.compile(
+        r"(?<!\S)(?:в )?(?P<edge>начало|конец) (?P<which>этот|следующий|последующий|прошлый|предыдущий) (?P<unit>неделя|месяц)(?!\S)",
+        re.IGNORECASE,
+    )
+
+    @classmethod
+    def temporal_vocabulary(cls) -> set[str]:
+        """Возвращает словарь временных терминов."""
+        vocab: set[str] = set()
+        vocab.update(cls.MONTHS)
+        vocab.update(cls.WEEKDAYS)
+        vocab.update(cls.DIRECT_RELATIVE)
+        vocab.update(cls.ORDINAL_DAYS)
+        vocab.update(cls.NUMBER_WORDS)
+        vocab.update({
+            "неделя", "месяц", "день", "назад", "через", "начало", "конец", "на", "в", "во",
+            "этот", "прошлый", "предыдущий", "следующий", "последующий",
+        })
+        return vocab
+
+    @staticmethod
+    def similarity(left: str, right: str) -> float:
+        """Вычисляет схожесть двух строк."""
+        return difflib.SequenceMatcher(None, left, right).ratio()
+
+    @classmethod
+    def pick_temporal_correction(cls, normalized: str, raw_lemma: str) -> tuple[str, Optional[str]]:
+        """Подбирает коррекцию для временного термина."""
+        vocab = cls.temporal_vocabulary()
+        if raw_lemma in vocab or not normalized.isalpha() or len(normalized) < 5:
+            return raw_lemma, None
+
+        candidates = list(difflib.get_close_matches(normalized, list(vocab), n=4, cutoff=0.74))
+        candidates.extend(difflib.get_close_matches(raw_lemma, list(vocab), n=4, cutoff=0.74))
+        candidates = list(dict.fromkeys(candidates))
+        if not candidates:
+            return raw_lemma, None
+
+        best = max(candidates, key=lambda item: max(cls.similarity(normalized, item), cls.similarity(raw_lemma, item)))
+        best_score = max(cls.similarity(normalized, best), cls.similarity(raw_lemma, best))
+        return (best, f"{raw_lemma}->{best}") if best_score >= 0.80 else (raw_lemma, None)
+
+    @staticmethod
+    def normalize_word(word: str) -> str:
+        """Нормализует слово."""
+        return word.lower().replace("ё", "е")
+
+    @classmethod
+    def lemmatize(cls, word: str) -> str:
+        """Возвращает лемму слова."""
+        return MORPH.parse(word)[0].normal_form if word.isalpha() else word
+
+    @classmethod
+    def tokenize(cls, text: str) -> list[Token]:
+        """Токенизирует текст."""
+        tokens: list[Token] = []
+        lemma_cursor = 0
+
+        for match in WORD_RE.finditer(text):
+            original = match.group(0)
+            normalized = cls.normalize_word(original)
+            raw_lemma = cls.lemmatize(normalized)
+            lemma, correction = cls.pick_temporal_correction(normalized, raw_lemma)
+            lemma_start = lemma_cursor
+            lemma_end = lemma_start + len(lemma)
+            tokens.append(Token(original, normalized, raw_lemma, lemma, correction, match.start(), match.end(), lemma_start, lemma_end))
+            lemma_cursor = lemma_end + 1
+
+        return tokens
+
+    @staticmethod
+    def lemma_text(tokens: list[Token]) -> str:
+        """Возвращает текст из лемм токенов."""
+        return " ".join(token.lemma for token in tokens)
+
+    @staticmethod
+    def surface_text(text: str, tokens: list[Token], start_idx: int, end_idx: int) -> str:
+        """Возвращает исходный текст по индексам токенов."""
+        return text[tokens[start_idx].start:tokens[end_idx].end].strip() if tokens else ""
+
+    @staticmethod
+    def lemma_span_to_token_range(tokens: list[Token], span: tuple[int, int]) -> Optional[tuple[int, int]]:
+        """Преобразует позиции в тексте лемм в индексы токенов."""
+        start_char, end_char = span
+        start_idx = end_idx = None
+
+        for idx, token in enumerate(tokens):
+            if start_idx is None and token.lemma_start <= start_char < token.lemma_end:
+                start_idx = idx
+            if token.lemma_start < end_char <= token.lemma_end:
+                end_idx = idx
+                break
+
+        return (start_idx, end_idx) if start_idx is not None and end_idx is not None else None
+
+    @classmethod
+    def make_parsed_date(cls, text: str, tokens: list[Token], match, parsed_date: date) -> Optional[ParsedDate]:
+        """Создаёт ParsedDate из результата match."""
+        token_span = cls.lemma_span_to_token_range(tokens, match.span())
+        if token_span is None:
+            return None
+        return ParsedDate(parsed_date.isoformat(), cls.surface_text(text, tokens, token_span[0], token_span[1]))
+
+    @classmethod
+    def parse_number_phrase(cls, phrase: str) -> Optional[int]:
+        """Парсит числовую фразу (цифры или слова)."""
+        phrase = phrase.strip()
+        if not phrase:
+            return None
+        if phrase.isdigit():
+            return int(phrase)
+
+        parts = phrase.split()
+        if len(parts) == 1:
+            return cls.NUMBER_WORDS.get(parts[0])
+        if len(parts) == 2 and parts[0] in {"двадцать", "тридцать"}:
+            base = cls.NUMBER_WORDS.get(parts[0])
+            addon = cls.NUMBER_WORDS.get(parts[1])
+            if base is not None and addon is not None and 1 <= addon <= 9:
+                return base + addon
+        return None
+
+    @classmethod
+    def parse_day_phrase(cls, phrase: str) -> Optional[int]:
+        """Парсит день (число или порядковое слово)."""
+        if phrase.isdigit():
+            value = int(phrase)
+            return value if 1 <= value <= 31 else None
+        return cls.ORDINAL_DAYS.get(phrase.strip())
+
+    @staticmethod
+    def shift_months(value: date, months: int) -> date:
+        """Сдвигает дату на указанное число месяцев."""
+        month_index = value.month - 1 + months
+        year = value.year + month_index // 12
+        month = month_index % 12 + 1
+        day = min(value.day, calendar.monthrange(year, month)[1])
+        return date(year, month, day)
+
+    @staticmethod
+    def parse_numeric_absolute(tokens: list[Token]) -> Optional[ParsedDate]:
+        """Парсит числовые даты: 15.01.2025, 2025-01-15."""
+        for token in tokens:
+            separator = "." if "." in token.original else "-" if "-" in token.original else "/" if "/" in token.original else None
+            if separator is None:
+                continue
+
+            parts = token.original.split(separator)
+            if len(parts) != 3 or not all(part.isdigit() for part in parts):
+                continue
+
+            try:
+                if len(parts[0]) == 4:
+                    parsed = date(int(parts[0]), int(parts[1]), int(parts[2]))
+                elif len(parts[2]) == 4:
+                    parsed = date(int(parts[2]), int(parts[1]), int(parts[0]))
+                else:
+                    continue
+                return ParsedDate(parsed.isoformat(), token.original)
+            except ValueError:
+                continue
+
+        return None
+
+    @classmethod
+    def parse_textual_absolute(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
+        """Парсит текстовые даты: 5 марта, 15 января 2025."""
+        lemma_text = cls.lemma_text(tokens)
+        for match in cls.TEXTUAL_ABSOLUTE_RE.finditer(lemma_text):
+            day = cls.parse_day_phrase(match.group("day"))
+            month = cls.MONTHS.get(match.group("month"))
+            if day is None or month is None:
+                continue
+
+            year = int(match.group("year")) if match.group("year") else reference_date.year
+            try:
+                parsed = date(year, month, day)
+            except ValueError:
+                continue
+
+            result = cls.make_parsed_date(text, tokens, match, parsed)
+            if result is not None:
+                return result
+
+        return None
+
+    @classmethod
+    def parse_direct_relative(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
+        """Парсит прямые относительные даты: вчера, завтра, позавчера, послезавтра."""
+        lemma_text = cls.lemma_text(tokens)
+        match = cls.DIRECT_RELATIVE_RE.search(lemma_text)
+        if not match:
+            return None
+
+        parsed = reference_date + timedelta(days=cls.DIRECT_RELATIVE[match.group(1)])
+        return cls.make_parsed_date(text, tokens, match, parsed)
+
+    @staticmethod
+    def week_monday(value: date) -> date:
+        """Возвращает понедельник недели для указанной даты."""
+        return value - timedelta(days=value.weekday())
+
+    @classmethod
+    def parse_week_relative(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
+        """Парсит недельные относительные даты: на следующей неделе, на прошлой неделе."""
+        lemma_text = cls.lemma_text(tokens)
+        match = cls.WEEK_RELATIVE_RE.search(lemma_text)
+        if not match:
+            return None
+
+        offsets = {"следующий": 7, "последующий": 7, "прошлый": -7, "предыдущий": -7, "этот": 0}
+        anchor = reference_date + timedelta(days=offsets[match.group("which")])
+
+        if match.group("weekday"):
+            anchor = cls.week_monday(anchor) + timedelta(days=cls.WEEKDAYS[match.group("weekday")])
+
+        return cls.make_parsed_date(text, tokens, match, anchor)
+
+    @classmethod
+    def parse_period_edge(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
+        """Парсит края периодов: в конце месяца, в начале недели."""
+        lemma_text = cls.lemma_text(tokens)
+        match = cls.PERIOD_EDGE_RE.search(lemma_text)
+        if not match:
+            return None
+
+        edge, which, unit = match.group("edge"), match.group("which"), match.group("unit")
+
+        if unit == "неделя":
+            offsets = {"прошлый": -7, "предыдущий": -7, "этот": 0, "следующий": 7, "последующий": 7}
+            monday = cls.week_monday(reference_date + timedelta(days=offsets[which]))
+            parsed_date = monday if edge == "начало" else monday + timedelta(days=6)
+        else:
+            month_offset = {"прошлый": -1, "предыдущий": -1, "этот": 0, "следующий": 1, "последующий": 1}[which]
+            shifted = cls.shift_months(date(reference_date.year, reference_date.month, 1), month_offset)
+            parsed_date = shifted if edge == "начало" else date(shifted.year, shifted.month, calendar.monthrange(shifted.year, shifted.month)[1])
+
+        return cls.make_parsed_date(text, tokens, match, parsed_date)
+
+    @classmethod
+    def parse_quantity_relative(cls, text: str, tokens: list[Token], reference_date: date) -> Optional[ParsedDate]:
+        """Парсит количественные относительные даты: через 2 дня, 3 недели назад."""
+        lemma_text = cls.lemma_text(tokens)
+
+        for regex, direction in ((cls.QUANTITY_RELATIVE_RE, -1), (cls.FORWARD_QUANTITY_RE, 1)):
+            for match in regex.finditer(lemma_text):
+                number = cls.parse_number_phrase(match.group("number"))
+                if number is None:
+                    continue
+
+                unit = match.group("unit")
+                if unit == "месяц":
+                    anchor = cls.shift_months(reference_date, direction * number)
+                else:
+                    days = number * 7 if unit == "неделя" else number
+                    anchor = reference_date + timedelta(days=direction * days)
+
+                if match.group("weekday"):
+                    anchor = cls.week_monday(anchor) + timedelta(days=cls.WEEKDAYS[match.group("weekday")])
+
+                result = cls.make_parsed_date(text, tokens, match, anchor)
+                if result is not None:
+                    return result
+
+        for match in cls.FORWARD_SINGLE_UNIT_RE.finditer(lemma_text):
+            unit = match.group("unit")
+            if unit == "месяц":
+                anchor = cls.shift_months(reference_date, 1)
+            else:
+                days = 7 if unit == "неделя" else 1
+                anchor = reference_date + timedelta(days=days)
+
+            if match.group("weekday"):
+                anchor = cls.week_monday(anchor) + timedelta(days=cls.WEEKDAYS[match.group("weekday")])
+
+            result = cls.make_parsed_date(text, tokens, match, anchor)
+            if result is not None:
+                return result
+
+        return None
+
+    @classmethod
+    def preference_for_text(cls, tokens: list[Token]) -> str:
+        """Определяет предпочтение: прошлое или будущее."""
+        lemmas = [token.lemma for token in tokens]
+        future = sum(1 for hint in cls.FUTURE_HINTS if hint in lemmas)
+        past = sum(1 for hint in cls.PAST_HINTS if hint in lemmas)
+        return "future" if future > past else "past"
+
+    @staticmethod
+    def choose_best(matches: list[tuple[str, datetime]]) -> tuple[str, datetime]:
+        """Выбирает лучший результат из списка."""
+        return sorted(matches, key=lambda item: (len(item[0]), -item[1].timestamp()), reverse=True)[0]
+
+    def parse(self, text: str, reference_date: date) -> Optional[ParsedDate]:
+        """
+        Основной метод парсинга даты из текста.
+        
+        Args:
+            text: Текст для парсинга
+            reference_date: Базовая дата для относительных вычислений
+            
+        Returns:
+            ParsedDate с результатом или None
+        """
+        tokens = self.tokenize(text)
+
+        # Пробуем все парсеры по очереди
+        for parser in (
+            lambda: self.parse_numeric_absolute(tokens),
+            lambda: self.parse_textual_absolute(text, tokens, reference_date),
+            lambda: self.parse_direct_relative(text, tokens, reference_date),
+            lambda: self.parse_week_relative(text, tokens, reference_date),
+            lambda: self.parse_period_edge(text, tokens, reference_date),
+            lambda: self.parse_quantity_relative(text, tokens, reference_date),
+        ):
+            parsed = parser()
+            if parsed is not None:
+                return parsed
+
+        # Fallback: dateparser
+        normalized = " ".join(token.normalized for token in tokens)
+        relative_base = datetime.combine(reference_date, datetime.min.time()).replace(hour=12)
+        result = search_dates(
+            normalized,
+            languages=["ru"],
+            settings={
+                "RELATIVE_BASE": relative_base,
+                "PREFER_DATES_FROM": self.preference_for_text(tokens),
+                "STRICT_PARSING": False,
+                "REQUIRE_PARTS": [],
+                "NORMALIZE": True,
+                "RETURN_AS_TIMEZONE_AWARE": False,
+                "DATE_ORDER": "DMY",
+            },
+        )
+
+        filtered: list[tuple[str, datetime]] = []
+        for matched, value in result or []:
+            if isinstance(value, datetime) and not matched.strip().isdigit() and 2020 <= value.year <= 2100:
+                filtered.append((matched.strip(), value))
+
+        if not filtered:
+            return None
+
+        matched_expression, value = self.choose_best(filtered)
+        return ParsedDate(date_iso=value.date().isoformat(), matched_expression=matched_expression)
+
+
+class ExpenseDateExtractor:
+    """
+    Экстрактор дат для текста расходов.
+    
+    Обёртка над UniversalDateParser с удобным интерфейсом.
+    """
+    
+    def __init__(self) -> None:
+        self.parser = UniversalDateParser()
+
+    def extract(self, text: str, reference_date: str | date | None = None) -> dict[str, Any]:
+        """
+        Извлекает дату из текста.
+        
+        Args:
+            text: Текст для анализа
+            reference_date: Базовая дата (по умолчанию сегодня)
+            
+        Returns:
+            Словарь с date, date_iso, matched_date_phrase
+        """
+        ref_date = self.to_date(reference_date or date.today().isoformat())
+        parsed = self.parser.parse(text=text, reference_date=ref_date)
+
+        return {
+            "date": datetime.strptime(parsed.date_iso, "%Y-%m-%d").strftime("%d.%m.%Y") if parsed else None,
+            "date_iso": parsed.date_iso if parsed else None,
+            "matched_date_phrase": parsed.matched_expression if parsed else None,
+        }
+
+    @staticmethod
+    def to_date(value: str | date) -> date:
+        """Преобразует строку или date в date."""
+        return value if isinstance(value, date) else datetime.strptime(value, "%Y-%m-%d").date()

extractors/supplier_extractor.py

@@ -0,0 +1,402 @@
+"""
+Экстрактор поставщиков из текста.
+
+Использует комбинацию методов:
+- TF-IDF для символьных n-грамм
+- Фонетическое сравнение
+- Выравнивание токенов
+- Расстояние Левенштейна
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Any
+
+import iuliia
+from rapidfuzz import fuzz
+from rapidfuzz.distance import Levenshtein
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+from extractors.date_extractor import UniversalDateParser
+
+
+def normalize_text(text: str) -> str:
+    """Нормализует текст: lowercase, удаление диакритики и пунктуации."""
+    text = unicodedata.normalize("NFKD", text.lower())
+    text = "".join(ch for ch in text if not unicodedata.combining(ch))
+    return re.sub(r"[^\w\s]", "", text).strip()
+
+
+def variants(text: str) -> list[str]:
+    """Генерирует варианты текста (транслитерация)."""
+    base = normalize_text(text)
+    result = [base]
+
+    for schema in (iuliia.WIKIPEDIA, iuliia.MOSMETRO, iuliia.ALA_LC):
+        try:
+            v = normalize_text(schema.translate(base))
+            if v and v not in result:
+                result.append(v)
+        except Exception:
+            pass
+
+    for v in list(result):
+        core = " ".join(w for w in v.split() if len(w) > 1 and any(ch.isalpha() for ch in w))
+        core = normalize_text(core)
+        if core and core not in result:
+            result.insert(0, core)
+
+    return result
+
+
+def token_alignment_score(phrase_variant: str, candidate_tokens: list[str]) -> float:
+    """Вычисляет выравнивание токенов."""
+    phrase_tokens = [t for t in phrase_variant.split() if len(t) > 2]
+    if not phrase_tokens or not candidate_tokens:
+        return 0.0
+    best_scores = []
+    for pt in phrase_tokens:
+        best = 0.0
+        for ct in candidate_tokens:
+            sim = Levenshtein.normalized_similarity(pt, ct)
+            if sim > best:
+                best = sim
+        best_scores.append(best)
+    return sum(best_scores) / len(best_scores)
+
+
+def length_penalty(phrase_len: int, candidate_len: int) -> float:
+    """Штраф за разницу в длине."""
+    if phrase_len == 0 or candidate_len == 0:
+        return 0.0
+    ratio = min(phrase_len, candidate_len) / max(phrase_len, candidate_len)
+    if ratio >= 0.80:
+        return 1.0
+    if ratio >= 0.60:
+        return 0.90
+    if ratio >= 0.40:
+        return 0.70
+    return 0.50
+
+
+def canonicalize_for_similarity(text: str) -> str:
+    """Каноникализирует текст для фонетического сравнения."""
+    t = normalize_text(text).replace(" ", "")
+    replacements = (
+        ("sch", "sh"),
+        ("tch", "ch"),
+        ("dzh", "j"),
+        ("zh", "j"),
+        ("sh", "s"),
+        ("ch", "c"),
+        ("kh", "h"),
+        ("ph", "f"),
+        ("ck", "k"),
+        ("qu", "k"),
+        ("q", "k"),
+        ("w", "v"),
+        ("x", "ks"),
+        ("ts", "z"),
+        ("tz", "z"),
+    )
+    for src, dst in replacements:
+        t = t.replace(src, dst)
+    return re.sub(r"(.)\1+", r"\1", t)
+
+
+def phonetic_similarity(left: str, right: str) -> float:
+    """Вычисляет фонетическую схожесть."""
+    l = canonicalize_for_similarity(left)
+    r = canonicalize_for_similarity(right)
+    if not l or not r:
+        return 0.0
+    char = fuzz.ratio(l, r) / 100.0
+    lev = Levenshtein.normalized_similarity(l, r)
+    return 0.50 * char + 0.50 * lev
+
+
+class ExpenseSupplierExtractor:
+    """
+    Экстрактор поставщиков из текста.
+    
+    Ищет наиболее похожего поставщика из списка известных.
+    """
+    
+    def __init__(self, suppliers: list[str]) -> None:
+        self.suppliers = suppliers
+        self.sup_norm = [normalize_text(s) for s in suppliers]
+        self.sup_tokens = [s.split() for s in self.sup_norm]
+        self.sup_num_sets = [self.numeric_tokens(s) for s in self.sup_norm]
+        self.sup_number_tokens = {token for supplier in self.sup_tokens for token in supplier if token.isdigit()}
+        self.supplier_lexicon = [
+            token
+            for token in sorted({tok for tokens in self.sup_tokens for tok in tokens})
+            if token and not token.isdigit()
+        ]
+        self.tfidf = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5))
+        self.sup_mat = self.tfidf.fit_transform(self.sup_norm)
+        self.max_words = max(len(s.split()) for s in self.sup_norm)
+        self.variant_cache: dict[str, list[str]] = {}
+        self.lexical_token_cache: dict[str, float] = {}
+        self.phrase_support_cache: dict[str, float] = {}
+        self.noise_terms = {
+            "за", "на", "из", "для", "под", "над", "при", "без", "и", "или",
+            "купил", "купила", "купили", "покупка", "заказал", "заказала", "заказали",
+            "оплатил", "оплатила", "оплатили", "заплатил", "заплатила", "заплатили",
+            "был", "была", "было", "были", "утром", "днем", "днём", "вечером", "ночью",
+            "товар", "товары", "продукт", "продукты", "десерт", "еда",
+            "лей", "лея", "леи", "целых", "сотых", "сом", "сомов", "руб", "рублей", "грн", "usd", "eur",
+        }
+        self.noise_terms.update(UniversalDateParser.temporal_vocabulary())
+
+    @staticmethod
+    def numeric_tokens(text: str) -> set[str]:
+        """Извлекает числовые токены."""
+        return set(re.findall(r"\d+", text))
+
+    def cached_variants(self, text: str) -> list[str]:
+        """Кэширует варианты текста."""
+        key = normalize_text(text)
+        cached = self.variant_cache.get(key)
+        if cached is None:
+            cached = variants(key)
+            self.variant_cache[key] = cached
+        return cached
+
+    @staticmethod
+    def split_words(text: str) -> list[str]:
+        """Разбивает текст на слова."""
+        return [w for w in normalize_text(text).split() if w]
+
+    @classmethod
+    def is_supplier_extension(cls, base_supplier: str, extended_supplier: str) -> bool:
+        """Проверяет, является ли один поставщик расширением другого."""
+        base_tokens = cls.split_words(base_supplier)
+        extended_tokens = cls.split_words(extended_supplier)
+        return len(base_tokens) < len(extended_tokens) and extended_tokens[:len(base_tokens)] == base_tokens
+
+    @classmethod
+    def phrase_token_count(cls, phrase: str | None) -> int:
+        """Считает количество токенов во фразе."""
+        return len(cls.split_words(phrase or ""))
+
+    @classmethod
+    def resolve_overlapping_suppliers(cls, ranking: list[dict[str, Any]]) -> dict[str, Any]:
+        """Разрешает конфликты между похожими поставщиками."""
+        if not ranking:
+            return {"supplier": None, "score": -1.0, "phrase": None}
+
+        best = ranking[0]
+        best_combined = float(best.get("combined", best.get("score", -1.0)))
+        best_phrase_len = cls.phrase_token_count(best.get("phrase"))
+
+        for alt in ranking[1:]:
+            if not cls.is_supplier_extension(str(best.get("supplier") or ""), str(alt.get("supplier") or "")):
+                continue
+
+            alt_combined = float(alt.get("combined", alt.get("score", -1.0)))
+            alt_phrase_len = cls.phrase_token_count(alt.get("phrase"))
+
+            if alt_phrase_len > best_phrase_len and alt_combined >= best_combined - 0.15:
+                best = alt
+                best_combined = alt_combined
+                best_phrase_len = alt_phrase_len
+
+        return best
+
+    @staticmethod
+    def numeric_compatibility_multiplier(phrase_nums: set[str], candidate_nums: set[str]) -> float:
+        """Множитель совместимости числовых токенов."""
+        if not phrase_nums and not candidate_nums:
+            return 1.0
+        if phrase_nums == candidate_nums:
+            return 1.08
+        if phrase_nums and candidate_nums:
+            return 1.03 if phrase_nums & candidate_nums else 0.80
+        return 0.82
+
+    def lexical_support(self, phrase: str) -> float:
+        """Вычисляет лексическую поддержку фразы."""
+        tokens = [token for token in normalize_text(phrase).split() if token and not token.isdigit()]
+        if not tokens or not self.supplier_lexicon:
+            return 0.0
+
+        support_scores: list[float] = []
+        for token in tokens:
+            cached = self.lexical_token_cache.get(token)
+            if cached is not None:
+                support_scores.append(cached)
+                continue
+
+            best = 0.0
+            for token_variant in self.cached_variants(token):
+                for lex in self.supplier_lexicon:
+                    lev = Levenshtein.normalized_similarity(token_variant, lex)
+                    phon = phonetic_similarity(token_variant, lex)
+                    sim = max(lev, phon)
+                    if sim > best:
+                        best = sim
+
+            self.lexical_token_cache[token] = best
+            support_scores.append(best)
+
+        return sum(support_scores) / len(support_scores)
+
+    def score_phrase(self, phrase: str) -> dict[str, Any]:
+        """Оценивает фразу на соответствие поставщикам."""
+        vs = self.cached_variants(phrase)
+        q = self.tfidf.transform(vs)
+        tf = cosine_similarity(q, self.sup_mat)
+
+        best: dict[str, Any] = {"supplier": None, "score": -1.0, "phrase": phrase, "variant": ""}
+        for i, cand in enumerate(self.sup_norm):
+            local = -1.0
+            local_variant = ""
+            candidate_nums = self.sup_num_sets[i]
+            for j, v in enumerate(vs):
+                char = fuzz.ratio(v, cand) / 100.0
+                tf_val = float(tf[j, i])
+                penalty = length_penalty(len(v), len(cand))
+                phon = phonetic_similarity(v, cand)
+                phrase_nums = self.numeric_tokens(v)
+
+                if len(v.split()) == 1 and len(cand.split()) == 1:
+                    lev = Levenshtein.normalized_similarity(v, cand)
+                    val = (0.45 * lev + 0.25 * char + 0.10 * tf_val + 0.20 * phon) * penalty
+                else:
+                    align = token_alignment_score(v, self.sup_tokens[i])
+                    tok = fuzz.token_set_ratio(v, cand) / 100.0
+                    val = (0.30 * char + 0.20 * tok + 0.10 * tf_val + 0.20 * align + 0.20 * phon) * penalty
+
+                    compact_v = v.replace(" ", "")
+                    compact_cand = cand.replace(" ", "")
+                    compact_char = fuzz.ratio(compact_v, compact_cand) / 100.0
+                    compact_lev = Levenshtein.normalized_similarity(compact_v, compact_cand)
+                    compact_phon = phonetic_similarity(compact_v, compact_cand)
+                    compact = max(compact_char, compact_lev, compact_phon)
+                    if compact > 0.55:
+                        val = max(val, compact * penalty)
+
+                val *= self.numeric_compatibility_multiplier(phrase_nums, candidate_nums)
+
+                if val > local:
+                    local = val
+                    local_variant = v
+
+            if local > best["score"]:
+                best = {"supplier": self.suppliers[i], "score": local, "phrase": phrase, "variant": local_variant}
+        return best
+
+    def extract(self, text: str, date_phrase: str | None = None, debug: bool = False) -> dict[str, Any]:
+        """
+        Извлекает поставщика из текста.
+        
+        Args:
+            text: Текст для анализа
+            date_phrase: Фраза даты для исключения
+            debug: Включить отладочную информацию
+            
+        Returns:
+            Словарь с supplier, supplier_score, matched_supplier_phrase
+        """
+        threshold = 0.50
+        excluded_tokens: set[str] = set()
+        if date_phrase:
+            excluded_tokens.update(normalize_text(date_phrase).split())
+        excluded_tokens.update(self.noise_terms)
+
+        raw_tokens = normalize_text(text).split()
+        tokens: list[str] = []
+        for token in raw_tokens:
+            if token in excluded_tokens:
+                continue
+
+            if token.isdigit():
+                if token in self.sup_number_tokens:
+                    tokens.append(token)
+
+                if tokens and len(token) <= 3 and len(tokens[-1]) >= 4 and tokens[-1].isalpha():
+                    tokens.append(f"{tokens[-1]}{token}")
+                continue
+
+            if len(token) > 1:
+                tokens.append(token)
+
+        tokens = [t for t in tokens if len(t) > 1 and t not in excluded_tokens]
+
+        phrases: list[str] = []
+        seen: set[str] = set()
+        for i in range(len(tokens)):
+            for j in range(i + 1, min(i + 1 + self.max_words, len(tokens) + 1)):
+                p = " ".join(tokens[i:j])
+                if p not in seen:
+                    seen.add(p)
+                    phrases.append(p)
+
+        results = [self.score_phrase(p) for p in phrases]
+        candidate_rows: list[dict[str, Any]] = []
+        best_by_supplier: dict[str, dict[str, Any]] = {}
+        for row in results:
+            supplier = row["supplier"]
+            score = float(row.get("score", -1.0))
+            phrase = str(row.get("phrase") or "")
+            support = self.phrase_support_cache.get(phrase)
+            if support is None:
+                support = self.lexical_support(phrase)
+                self.phrase_support_cache[phrase] = support
+            combined = 0.75 * score + 0.25 * support
+
+            if debug:
+                candidate_rows.append({
+                    "supplier": supplier,
+                    "phrase": phrase,
+                    "score": round(score, 4),
+                    "support": round(support, 4),
+                    "combined": round(combined, 4),
+                })
+
+            enriched = {**row, "combined": combined}
+            passes = score >= threshold or combined >= 0.48
+            if passes and (supplier not in best_by_supplier or combined > float(best_by_supplier[supplier].get("combined", -1.0))):
+                best_by_supplier[supplier] = enriched
+
+        if not best_by_supplier and results:
+            def support_for_phrase(phrase: str) -> float:
+                cached_support = self.phrase_support_cache.get(phrase)
+                if cached_support is None:
+                    cached_support = self.lexical_support(phrase)
+                    self.phrase_support_cache[phrase] = cached_support
+                return cached_support
+
+            fallback = max(
+                results,
+                key=lambda item: 0.75 * float(item.get("score", -1.0)) + 0.25 * support_for_phrase(str(item.get("phrase") or "")),
+            )
+            fallback_score = float(fallback.get("score", -1.0))
+            fallback_phrase = str(fallback.get("phrase") or "")
+            fallback_support = support_for_phrase(fallback_phrase)
+            fallback_combined = 0.75 * fallback_score + 0.25 * fallback_support
+            if fallback_score >= 0.40 and fallback_support >= 0.43 and fallback_combined >= 0.43:
+                best_by_supplier[fallback["supplier"]] = {**fallback, "combined": fallback_combined}
+
+        supplier_ranking = sorted(best_by_supplier.values(), key=lambda x: float(x.get("combined", x["score"])), reverse=True)
+        best = self.resolve_overlapping_suppliers(supplier_ranking)
+
+        payload = {
+            "supplier": best["supplier"],
+            "supplier_score": round(best["score"], 4) if best["score"] >= 0 else None,
+            "matched_supplier_phrase": best.get("phrase"),
+        }
+
+        if debug:
+            top_candidates = sorted(candidate_rows, key=lambda item: item["combined"], reverse=True)[:8]
+            payload["supplier_debug"] = {
+                "tokens": tokens,
+                "phrases_count": len(phrases),
+                "top_candidates": top_candidates,
+            }
+
+        return payload

extractors/user_extractor.py

@@ -0,0 +1,142 @@
+"""
+Экстрактор пользователей из текста.
+
+Использует семантические эмбеддинги для поиска пользователей.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Any
+
+import torch
+from pymorphy3 import MorphAnalyzer
+from sentence_transformers import SentenceTransformer
+
+
+MORPH = MorphAnalyzer()
+
+
+def normalize_text(text: str) -> str:
+    """Нормализует текст: lowercase, удаление диакритики и пунктуации."""
+    text = unicodedata.normalize("NFKD", text.lower())
+    text = "".join(ch for ch in text if not unicodedata.combining(ch))
+    return re.sub(r"[^\w\s]", "", text).strip()
+
+
+def tokenize_text(text: str) -> list[str]:
+    """Токенизирует текст."""
+    return normalize_text(text).split()
+
+
+def lemmatize_word(word: str) -> str:
+    """Возвращает лемму слова."""
+    return MORPH.parse(word)[0].normal_form if re.fullmatch(r"[а-я]+", word) else word
+
+
+def lemmatize_text(text: str) -> list[str]:
+    """Лемматизирует текст."""
+    return [lemmatize_word(word) for word in tokenize_text(text)]
+
+
+class ExpenseUserExtractor:
+    """
+    Экстрактор пользователей из текста.
+    
+    Использует семантические эмбеддинги для сопоставления слов из текста
+    с известными пользователями.
+    """
+    
+    def __init__(
+        self, 
+        users: list[str], 
+        suppliers: list[str], 
+        model: SentenceTransformer, 
+        threshold: float = 0.6
+    ) -> None:
+        """
+        Args:
+            users: Список известных пользователей
+            suppliers: Список поставщиков (для исключения)
+            model: Модель для создания эмбеддингов
+            threshold: Порог схожести
+        """
+        self.users = users
+        self.model = model
+        self.threshold = threshold
+        self.supplier_terms = {normalize_text(supplier) for supplier in suppliers}
+        self.user_terms = [normalize_text(user) for user in users]
+        self.user_embeddings = model.encode(
+            [f"passage: {user}" for user in self.user_terms],
+            convert_to_tensor=True,
+            normalize_embeddings=True,
+        )
+
+    def extract(
+        self, 
+        text: str, 
+        supplier_phrase: str | None = None, 
+        date_phrase: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Извлекает пользователя из текста.
+        
+        Args:
+            text: Текст для анализа
+            supplier_phrase: Фраза поставщика для исключения
+            date_phrase: Фраза даты для исключения
+            
+        Returns:
+            Словарь с user, user_score, matched_user_phrase
+        """
+        excluded_tokens: set[str] = set()
+        if supplier_phrase:
+            excluded_tokens.update(normalize_text(supplier_phrase).split())
+        if date_phrase:
+            excluded_tokens.update(normalize_text(date_phrase).split())
+
+        best_user = None
+        best_score = -1.0
+        best_phrase = None
+
+        for word in lemmatize_text(text):
+            if len(word) < 3:
+                continue
+            if word in excluded_tokens or word in self.supplier_terms:
+                continue
+
+            query_emb = self.model.encode(
+                f"query: {word}",
+                convert_to_tensor=True,
+                normalize_embeddings=True,
+            )
+            similarities = torch.cosine_similarity(query_emb.unsqueeze(0), self.user_embeddings, dim=1)
+            idx = int(torch.argmax(similarities))
+            score = similarities[idx].item()
+
+            if score > best_score:
+                best_score = score
+                best_user = self.users[idx]
+                best_phrase = word
+
+        if best_score >= self.threshold:
+            return {
+                "user": best_user,
+                "user_score": round(best_score, 4),
+                "matched_user_phrase": best_phrase,
+            }
+
+        # Проверка на местоимение "я"
+        if re.search(r"(?<!\S)я(?!\S)", normalize_text(text), re.IGNORECASE):
+            return {
+                "user": "Я",
+                "user_score": 1.0,
+                "matched_user_phrase": "я",
+            }
+
+        return {
+            "user": None,
+            "user_score": None,
+            "matched_user_phrase": None,
+        }

natasha_dates.py

@@ -1,589 +0,0 @@
-"""
-Универсальный парсер дат для русского языка.
-Использует собственные правила + опционально Natasha как fallback.
-Поддерживает: точные даты, относительные, порядковые числительные, числа словами.
-"""
-
-import re
-from datetime import date, datetime, timedelta
-from typing import Any, Optional, Callable
-from dateutil.relativedelta import relativedelta
-
-# Опциональный импорт Natasha
-try:
-    from natasha import DatesExtractor, MorphVocab
-    NATASHA_AVAILABLE = True
-except ImportError:
-    NATASHA_AVAILABLE = False
-    DatesExtractor = None
-    MorphVocab = None
-
-# Инициализация Natasha (ленивая)
-_MORPH_VOCAB = None
-_DATES_EXTRACTOR = None
-
-
-def _get_extractor():
-    """Ленивая инициализация экстрактора Natasha."""
-    global _MORPH_VOCAB, _DATES_EXTRACTOR
-    if not NATASHA_AVAILABLE:
-        return None
-    if _DATES_EXTRACTOR is None:
-        _MORPH_VOCAB = MorphVocab()
-        _DATES_EXTRACTOR = DatesExtractor(_MORPH_VOCAB)
-    return _DATES_EXTRACTOR
-
-
-# ============== СЛОВАРИ ==============
-
-MONTHS = {
-    "январь": 1, "января": 1, "январе": 1,
-    "февраль": 2, "февраля": 2, "феврале": 2,
-    "март": 3, "марта": 3, "марте": 3,
-    "апрель": 4, "апреля": 4, "апреле": 4,
-    "май": 5, "мая": 5, "мае": 5,
-    "июнь": 6, "июня": 6, "июне": 6,
-    "июль": 7, "июля": 7, "июле": 7,
-    "август": 8, "августа": 8, "августе": 8,
-    "сентябрь": 9, "сентября": 9, "сентябре": 9,
-    "октябрь": 10, "октября": 10, "октябре": 10,
-    "ноябрь": 11, "ноября": 11, "ноябре": 11,
-    "декабрь": 12, "декабря": 12, "декабре": 12,
-}
-
-WEEKDAYS = {
-    "понедельник": 0, "вторник": 1, "среда": 2, "среду": 2,
-    "четверг": 3, "пятница": 4, "пятницу": 4,
-    "суббота": 5, "субботу": 5, "воскресенье": 6,
-}
-
-# Числа словами (кардинальные)
-NUMBER_WORDS = {
-    "ноль": 0, "один": 1, "одну": 1, "одного": 1,
-    "два": 2, "две": 2, "двух": 2,
-    "три": 3, "трёх": 3, "трех": 3,
-    "четыре": 4, "четырёх": 4, "четырех": 4,
-    "пять": 5, "пяти": 5,
-    "шесть": 6, "шести": 6,
-    "семь": 7, "семи": 7,
-    "восемь": 8, "восьми": 8,
-    "девять": 9, "девяти": 9,
-    "десять": 10, "десяти": 10,
-    "одиннадцать": 11, "двенадцать": 12, "тринадцать": 13,
-    "четырнадцать": 14, "пятнадцать": 15, "шестнадцать": 16,
-    "семнадцать": 17, "восемнадцать": 18, "девятнадцать": 19,
-    "двадцать": 20, "тридцать": 30,
-}
-
-# Порядковые числительные для дней
-ORDINAL_DAYS = {
-    "первое": 1, "первого": 1, "первом": 1,
-    "второе": 2, "второго": 2, "втором": 2,
-    "третье": 3, "третьего": 3, "третьем": 3,
-    "четвёртое": 4, "четвертое": 4, "четвёртого": 4, "четвертого": 4,
-    "пятое": 5, "пятого": 5,
-    "шестое": 6, "шестого": 6,
-    "седьмое": 7, "седьмого": 7,
-    "восьмое": 8, "восьмого": 8,
-    "девятое": 9, "девятого": 9,
-    "десятое": 10, "десятого": 10,
-    "одиннадцатое": 11, "одиннадцатого": 11,
-    "двенадцатое": 12, "двенадцатого": 12,
-    "тринадцатое": 13, "тринадцатого": 13,
-    "четырнадцатое": 14, "четырнадцатого": 14,
-    "пятнадцатое": 15, "пятнадцатого": 15,
-    "шестнадцатое": 16, "шестнадцатого": 16,
-    "семнадцатое": 17, "семнадцатого": 17,
-    "восемнадцатое": 18, "восемнадцатого": 18,
-    "девятнадцатое": 19, "девятнадцатого": 19,
-    "двадцатое": 20, "двадцатого": 20,
-    "двадцать первое": 21, "двадцать первого": 21,
-    "двадцать второе": 22, "двадцать второго": 22,
-    "двадцать третье": 23, "двадцать третьего": 23,
-    "двадцать четвёртое": 24, "двадцать четвертое": 24, "двадцать четвёртого": 24, "двадцать четвертого": 24,
-    "двадцать пятое": 25, "двадцать пятого": 25,
-    "двадцать шестое": 26, "двадцать шестого": 26,
-    "двадцать седьмое": 27, "двадцать седьмого": 27,
-    "двадцать восьмое": 28, "двадцать восьмого": 28,
-    "двадцать девятое": 29, "двадцать девятого": 29,
-    "тридцатое": 30, "тридцатого": 30,
-    "тридцать первое": 31, "тридцать первого": 31,
-}
-
-# Контекст прошлого/будущего
-PAST_INDICATORS = re.compile(
-    r'\b(оплата|оплатил[аи]?|заплатил[аи]?|купил[аи]?|заказал[аи]?|'
-    r'потратил[аи]?|был[аио]?|получил[аи]?|сделал[аи]?|прошл[аоыйую]|'
-    r'предыдущ[аоыйую]|назад)\b',
-    re.IGNORECASE
-)
-
-FUTURE_INDICATORS = re.compile(
-    r'\b(завтра|послезавтра|через|следующ[аоыйую]|будущ[аоыйую]|'
-    r'заплатить|купить|заказать)\b',
-    re.IGNORECASE
-)
-
-
-# ============== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==============
-
-def _parse_number(text: str) -> Optional[int]:
-    """Парсит число из текста (цифры или словами)."""
-    text = text.strip().lower().replace('ё', 'е')
-    
-    # Цифры
-    if text.isdigit():
-        return int(text)
-    
-    # Одно слово
-    if text in NUMBER_WORDS:
-        return NUMBER_WORDS[text]
-    
-    # Два слова (двадцать один)
-    parts = text.split()
-    if len(parts) == 2:
-        tens = NUMBER_WORDS.get(parts[0])
-        units = NUMBER_WORDS.get(parts[1])
-        if tens in (20, 30) and units and 1 <= units <= 9:
-            return tens + units
-    
-    return None
-
-
-def _parse_day(text: str) -> Optional[int]:
-    """Парсит день месяца (цифры или порядковые числительные)."""
-    text = text.strip().lower().replace('ё', 'е')
-    
-    if text.isdigit():
-        val = int(text)
-        return val if 1 <= val <= 31 else None
-    
-    # Порядковые числительные
-    if text in ORDINAL_DAYS:
-        return ORDINAL_DAYS[text]
-    
-    # Составные порядковые (двадцать первого)
-    for phrase, day in ORDINAL_DAYS.items():
-        if ' ' in phrase and phrase in text:
-            return day
-    
-    return None
-
-
-def _week_start(ref: date) -> date:
-    """Понедельник текущей недели."""
-    return ref - timedelta(days=ref.weekday())
-
-
-def _get_weekday_date(weekday: int, ref: date, direction: str) -> date:
-    """Находит дату дня недели относительно ref."""
-    days_diff = weekday - ref.weekday()
-    
-    if direction == 'past':
-        if days_diff >= 0:
-            days_diff -= 7
-    elif direction == 'next':
-        if days_diff <= 0:
-            days_diff += 7
-    # 'this' - ближайший
-    
-    return ref + timedelta(days=days_diff)
-
-
-def _adjust_year_by_context(parsed_date: date, text: str, ref: date) -> date:
-    """Корректирует год по контексту (прошлое/будущее)."""
-    has_past = bool(PAST_INDICATORS.search(text))
-    has_future = bool(FUTURE_INDICATORS.search(text))
-    
-    # Если явно прошлое и дата в будущем
-    if has_past and not has_future and parsed_date > ref:
-        return parsed_date - relativedelta(years=1)
-    
-    # Если явно будущее и дата в прошлом
-    if has_future and not has_past and parsed_date < ref:
-        return parsed_date + relativedelta(years=1)
-    
-    return parsed_date
-
-
-# ============== ПАРСЕРЫ ==============
-
-def _parse_direct_relative(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Прямые относительные: сегодня, завтра, вчера..."""
-    patterns = [
-        (r'\bпослезавтра\b', 2),
-        (r'\bпозавчера\b', -2),
-        (r'\bсегодня\b', 0),
-        (r'\bзавтра\b', 1),
-        (r'\bвчера\b', -1),
-    ]
-    text_lower = text.lower()
-    for pattern, delta in patterns:
-        match = re.search(pattern, text_lower)
-        if match:
-            return ref + timedelta(days=delta), match.group(0)
-    return None
-
-
-def _parse_quantity_relative(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Количественные: через 2 дня, 3 недели назад..."""
-    text_lower = text.lower()
-    
-    # через X дней/недель/месяцев
-    patterns_forward = [
-        (r'\bчерез\s+(\d+|[а-яё]+(?:\s+[а-яё]+)?)\s+(день|дня|дней)\b', 'days'),
-        (r'\bчерез\s+(\d+|[а-яё]+(?:\s+[а-яё]+)?)\s+(неделю|недели|недель)\b', 'weeks'),
-        (r'\bчерез\s+(\d+|[а-яё]+(?:\s+[а-яё]+)?)\s+(месяц|месяца|месяцев)\b', 'months'),
-    ]
-    
-    for pattern, unit in patterns_forward:
-        match = re.search(pattern, text_lower)
-        if match:
-            num = _parse_number(match.group(1))
-            if num:
-                if unit == 'days':
-                    return ref + timedelta(days=num), match.group(0)
-                elif unit == 'weeks':
-                    return ref + timedelta(weeks=num), match.group(0)
-                elif unit == 'months':
-                    return ref + relativedelta(months=num), match.group(0)
-    
-    # X дней/недель/месяцев назад
-    patterns_back = [
-        (r'\b(\d+|[а-яё]+(?:\s+[а-яё]+)?)\s+(день|дня|дней)\s+назад\b', 'days'),
-        (r'\b(\d+|[а-яё]+(?:\s+[а-яё]+)?)\s+(неделю|недели|недель)\s+назад\b', 'weeks'),
-        (r'\b(\d+|[а-яё]+(?:\s+[а-яё]+)?)\s+(месяц|месяца|месяцев)\s+назад\b', 'months'),
-    ]
-    
-    for pattern, unit in patterns_back:
-        match = re.search(pattern, text_lower)
-        if match:
-            num = _parse_number(match.group(1))
-            if num:
-                if unit == 'days':
-                    return ref - timedelta(days=num), match.group(0)
-                elif unit == 'weeks':
-                    return ref - timedelta(weeks=num), match.group(0)
-                elif unit == 'months':
-                    return ref - relativedelta(months=num), match.group(0)
-    
-    return None
-
-
-def _parse_week_relative(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Недельные: на следующей неделе, на прошлой неделе..."""
-    text_lower = text.lower()
-    
-    # на следующей/прошлой/этой неделе
-    week_patterns = [
-        (r'\b(?:на\s+)?следующ(?:ей|ую)\s+недел[юеи]\b', 7),
-        (r'\b(?:на\s+)?прошл(?:ой|ую)\s+недел[юеи]\b', -7),
-        (r'\b(?:на\s+)?предыдущ(?:ей|ую)\s+недел[юеи]\b', -7),
-        (r'\b(?:на\s+)?этой\s+неделе\b', 0),
-        (r'\b(?:на\s+)?текущ(?:ей|ую)\s+недел[юеи]\b', 0),
-        (r'\bчерез\s+неделю\b', 7),
-        (r'\bнеделю\s+назад\b', -7),
-    ]
-    
-    for pattern, delta in week_patterns:
-        match = re.search(pattern, text_lower)
-        if match:
-            # Понедельник целевой недели
-            target_monday = _week_start(ref) + timedelta(days=delta)
-            return target_monday, match.group(0)
-    
-    return None
-
-
-def _parse_weekday(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Дни недели: в прошлый понедельник, в следующую пятницу..."""
-    text_lower = text.lower()
-    
-    # Прошлый день недели
-    match = re.search(
-        r'\b(?:в\s+)?прошл(?:ый|ую)\s+(понедельник|вторник|сред[ау]|четверг|пятниц[ау]|суббот[ау]|воскресенье)\b',
-        text_lower
-    )
-    if match:
-        weekday_text = match.group(1).replace('у', 'а') if match.group(1).endswith('у') else match.group(1)
-        weekday = WEEKDAYS.get(weekday_text) or WEEKDAYS.get(match.group(1))
-        if weekday is not None:
-            return _get_weekday_date(weekday, ref, 'past'), match.group(0)
-    
-    # Следующий день недели
-    match = re.search(
-        r'\b(?:в\s+)?следующ(?:ий|ую)\s+(понедельник|вторник|сред[ау]|четверг|пятниц[ау]|суббот[ау]|воскресенье)\b',
-        text_lower
-    )
-    if match:
-        weekday_text = match.group(1)
-        weekday = WEEKDAYS.get(weekday_text)
-        if weekday is not None:
-            return _get_weekday_date(weekday, ref, 'next'), match.group(0)
-    
-    # Этот день недели
-    match = re.search(
-        r'\b(?:в\s+)?(?:этот|эту)\s+(понедельник|вторник|сред[ау]|четверг|пятниц[ау]|суббот[ау]|воскресенье)\b',
-        text_lower
-    )
-    if match:
-        weekday = WEEKDAYS.get(match.group(1))
-        if weekday is not None:
-            return _get_weekday_date(weekday, ref, 'this'), match.group(0)
-    
-    return None
-
-
-def _parse_period_edge(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Границы периодов: в начале месяца, в конце недели..."""
-    text_lower = text.lower()
-    
-    # Начало/конец месяца
-    match = re.search(r'\b(?:в\s+)?начал[еоа]\s+месяца\b', text_lower)
-    if match:
-        return ref.replace(day=1), match.group(0)
-    
-    match = re.search(r'\b(?:в\s+)?конц[еа]\s+месяца\b', text_lower)
-    if match:
-        last_day = (ref.replace(day=1) + relativedelta(months=1) - timedelta(days=1)).day
-        return ref.replace(day=last_day), match.group(0)
-    
-    # Начало/конец недели
-    match = re.search(r'\b(?:в\s+)?начал[еоа]\s+недели\b', text_lower)
-    if match:
-        return _week_start(ref), match.group(0)
-    
-    match = re.search(r'\b(?:в\s+)?конц[еа]\s+недели\b', text_lower)
-    if match:
-        return _week_start(ref) + timedelta(days=6), match.group(0)
-    
-    # Начало/конец следующего месяца
-    match = re.search(r'\b(?:в\s+)?начал[еоа]\s+следующего\s+месяца\b', text_lower)
-    if match:
-        return (ref.replace(day=1) + relativedelta(months=1)), match.group(0)
-    
-    match = re.search(r'\b(?:в\s+)?конц[еа]\s+следующего\s+месяца\b', text_lower)
-    if match:
-        next_month = ref.replace(day=1) + relativedelta(months=2) - timedelta(days=1)
-        return next_month, match.group(0)
-    
-    return None
-
-
-def _parse_textual_date(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Текстовые даты: 15 января, пятого марта 2025..."""
-    text_lower = text.lower().replace('ё', 'е')
-    
-    # Порядковые + месяц: пятого марта, двадцать первого января
-    for ordinal, day in sorted(ORDINAL_DAYS.items(), key=lambda x: -len(x[0])):
-        for month_name, month_num in MONTHS.items():
-            pattern = rf'\b{re.escape(ordinal)}\s+{re.escape(month_name)}(?:\s+(\d{{4}}))?\b'
-            match = re.search(pattern, text_lower)
-            if match:
-                year = int(match.group(1)) if match.group(1) else ref.year
-                try:
-                    parsed = date(year, month_num, day)
-                    parsed = _adjust_year_by_context(parsed, text, ref)
-                    return parsed, match.group(0)
-                except ValueError:
-                    continue
-    
-    # Цифра + месяц: 15 января 2025
-    for month_name, month_num in MONTHS.items():
-        pattern = rf'\b(\d{{1,2}})\s+{re.escape(month_name)}(?:\s+(\d{{4}}))?\b'
-        match = re.search(pattern, text_lower)
-        if match:
-            day = int(match.group(1))
-            year = int(match.group(2)) if match.group(2) else ref.year
-            if 1 <= day <= 31:
-                try:
-                    parsed = date(year, month_num, day)
-                    parsed = _adjust_year_by_context(parsed, text, ref)
-                    return parsed, match.group(0)
-                except ValueError:
-                    continue
-    
-    return None
-
-
-def _parse_month_only(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Только месяц: за март, в апреле..."""
-    text_lower = text.lower()
-    
-    for month_name, month_num in MONTHS.items():
-        pattern = rf'\b(?:за|в|на)\s+{re.escape(month_name)}\b'
-        match = re.search(pattern, text_lower)
-        if match:
-            year = ref.year
-            # Контекст определяет год
-            if PAST_INDICATORS.search(text) and month_num > ref.month:
-                year -= 1
-            elif not PAST_INDICATORS.search(text) and month_num < ref.month:
-                # Если месяц уже прошёл и нет индикаторов - следующий год? 
-                # Нет, оставляем текущий год по умолчанию
-                pass
-            
-            return date(year, month_num, 1), match.group(0)
-    
-    return None
-
-
-def _parse_numeric_date(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Числовые даты: 15.01.2025, 2025-01-15..."""
-    # DD.MM.YYYY или DD/MM/YYYY или DD-MM-YYYY
-    match = re.search(r'\b(\d{1,2})[./\-](\d{1,2})[./\-](\d{4})\b', text)
-    if match:
-        day, month, year = int(match.group(1)), int(match.group(2)), int(match.group(3))
-        try:
-            return date(year, month, day), match.group(0)
-        except ValueError:
-            pass
-    
-    # YYYY-MM-DD
-    match = re.search(r'\b(\d{4})[./\-](\d{1,2})[./\-](\d{1,2})\b', text)
-    if match:
-        year, month, day = int(match.group(1)), int(match.group(2)), int(match.group(3))
-        try:
-            return date(year, month, day), match.group(0)
-        except ValueError:
-            pass
-    
-    return None
-
-
-def _parse_with_natasha(text: str, ref: date) -> Optional[tuple[date, str]]:
-    """Natasha как fallback для сложных случаев."""
-    if not NATASHA_AVAILABLE:
-        return None
-    
-    try:
-        extractor = _get_extractor()
-        if extractor is None:
-            return None
-        
-        matches = list(extractor(text))
-        
-        if matches:
-            match = matches[0]
-            fact = match.fact
-            
-            year = getattr(fact, 'year', None) or ref.year
-            month = getattr(fact, 'month', None)
-            day = getattr(fact, 'day', None) or 1
-            
-            if month:
-                try:
-                    parsed = date(year, month, day)
-                    parsed = _adjust_year_by_context(parsed, text, ref)
-                    return parsed, text[match.start:match.stop]
-                except ValueError:
-                    pass
-    except Exception:
-        pass
-    
-    return None
-
-
-# ============== ГЛАВНАЯ ФУНКЦИЯ ==============
-
-def parse_date_natasha(
-    text: str,
-    reference_date: Optional[date] = None
-) -> dict[str, Any]:
-    """
-    Универсальный парсер дат для русского языка.
-    
-    Поддерживает:
-    - Прямые относительные: сегодня, завтра, вчера, послезавтра, позавчера
-    - Количественные: через 2 дня, 3 недели назад, через два месяца
-    - Недельные: на следующей неделе, на прошлой неделе
-    - Дни недели: в прошлый понедельник, в следующую пятницу
-    - Границы периодов: в начале месяца, в конце недели
-    - Текстовые: 15 января 2025, пятого марта
-    - Месяцы: за март, в апреле
-    - Числовые: 15.01.2025, 2025-01-15
-    
-    Args:
-        text: Текст для анализа
-        reference_date: Опорная дата (по умолчанию - сегодня)
-    
-    Returns:
-        {"date": "19.04.2026", "date_iso": "2026-04-19", "matched_date_phrase": "..."}
-    """
-    if reference_date is None:
-        reference_date = date.today()
-    
-    result = {
-        "date": None,
-        "date_iso": None,
-        "matched_date_phrase": None,
-    }
-    
-    # Порядок парсеров: от простых к сложным
-    parsers: list[Callable[[str, date], Optional[tuple[date, str]]]] = [
-        _parse_numeric_date,      # 15.01.2025
-        _parse_direct_relative,   # завтра, вчера
-        _parse_quantity_relative, # через 2 дня
-        _parse_week_relative,     # на следующей неделе
-        _parse_weekday,           # в прошлый понедельник
-        _parse_period_edge,       # в конце месяца
-        _parse_textual_date,      # 15 января, пятого марта
-        _parse_month_only,        # за март
-        _parse_with_natasha,      # Natasha fallback
-    ]
-    
-    for parser in parsers:
-        parsed = parser(text, reference_date)
-        if parsed:
-            parsed_date, matched = parsed
-            result["date"] = parsed_date.strftime("%d.%m.%Y")
-            result["date_iso"] = parsed_date.isoformat()
-            result["matched_date_phrase"] = matched
-            return result
-    
-    return result
-
-
-# ============== КЛАСС-ОБЁРТКА ==============
-
-class NatashaDateExtractor:
-    """Экстрактор дат для совместимости с ExpenseDateExtractor."""
-    
-    def extract(self, text: str, reference_date: Optional[date] = None) -> dict[str, Any]:
-        ref = reference_date or date.today()
-        if isinstance(ref, str):
-            ref = datetime.strptime(ref, "%Y-%m-%d").date()
-        return parse_date_natasha(text, ref)
-    
-    def extract_all(self, text: str, reference_date: Optional[date] = None) -> list[dict[str, Any]]:
-        # Для простоты возвращаем первый результат
-        result = self.extract(text, reference_date)
-        return [result] if result["date"] else []
-
-
-if __name__ == "__main__":
-    # Тестирование
-    test_phrases = [
-        "завтра",
-        "через 2 дня",
-        "через два дня",
-        "на следующей неделе",
-        "15 января 2025",
-        "позавчера",
-        "в прошлый понедельник",
-        "оплата за март",
-        "5 марта",
-        "купил вчера",
-        "в конце месяца",
-        "пятого марта",
-        "двадцать первого января",
-        "3 недели назад",
-        "через месяц",
-    ]
-    
-    ref = date(2026, 4, 19)
-    print(f"Reference: {ref}\n")
-    
-    for phrase in test_phrases:
-        result = parse_date_natasha(phrase, ref)
-        print(f"  '{phrase}' -> {result['date_iso']} ({result['matched_date_phrase']})")

requirements.txt

@@ -10,4 +10,3 @@ torch
 sentence-transformers
 scikit-learn
 gliner
-natasha