Add Duckling integration

Dockerfile

@@ -0,0 +1,43 @@
+# Stage 1: Копируем Duckling из официального образа
+FROM rasa/duckling:latest AS duckling
+
+# Stage 2: Основной образ
+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 \
+    DUCKLING_URL=http://localhost:8000/parse
+
+# Установка зависимостей: ffmpeg, supervisor, и библиотеки для Duckling
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    supervisor \
+    libgmp10 \
+    libpcre3 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Копируем бинарник Duckling и делаем его исполняемым
+COPY --from=duckling /usr/local/bin/duckling-example-exe /usr/local/bin/duckling-example-exe
+RUN chmod +x /usr/local/bin/duckling-example-exe
+
+RUN useradd -m -u 1000 user
+
+USER user
+WORKDIR $HOME/app
+
+COPY --chown=user requirements.txt ./requirements.txt
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY --chown=user app.py ./app.py
+COPY --chown=user duckling_client.py ./duckling_client.py
+COPY --chown=user supervisord.conf ./supervisord.conf
+
+EXPOSE 7860
+
+# Запуск через supervisor (Duckling + Gunicorn)
+CMD ["supervisord", "-c", "supervisord.conf"]

app.py

@@ -0,0 +1,1287 @@
+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 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
+
+# Duckling клиент для извлечения дат
+from duckling_client import parse_date_with_duckling, parse_all_dates_with_duckling
+
+# 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
+
+
+app = Flask(__name__)
+app.config["MAX_CONTENT_LENGTH"] = 20 * 1024 * 1024
+
+
+def get_embedding_model() -> SentenceTransformer:
+    global _MODEL
+
+    if _MODEL is None:
+        _MODEL = SentenceTransformer("Qwen/Qwen3-Embedding-0.6B", device=DEVICE)
+
+    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:
+    global _WHISPER_MODEL
+
+    if _WHISPER_MODEL is None:
+        from faster_whisper import WhisperModel
+
+        model_name = os.getenv("WHISPER_MODEL", "large-v3")
+        compute_type = os.getenv("WHISPER_COMPUTE_TYPE", "float16" if torch.cuda.is_available() else "int8")
+        _WHISPER_MODEL = WhisperModel(model_name, device=DEVICE, compute_type=compute_type)
+
+    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()
+
+
+class DucklingDateExtractor:
+    """
+    Извлечение дат через Duckling.
+    Поддерживает как точные даты ("15 января 2025"), так и относительные ("завтра", "через 2 дня").
+    """
+    
+    def extract(self, text: str, reference_date: str | date | None = None) -> dict[str, Any]:
+        """
+        Извлекает дату из текста с помощью Duckling.
+        
+        Args:
+            text: Текст для анализа
+            reference_date: Опорная дата для относительных выражений (по умолчанию - сегодня)
+        
+        Returns:
+            {
+                "date": "19.04.2026",  # формат DD.MM.YYYY
+                "date_iso": "2026-04-19",  # формат ISO
+                "matched_date_phrase": "завтра"  # найденное выражение
+            }
+        """
+        ref_datetime = None
+        if reference_date:
+            ref_date = self.to_date(reference_date)
+            ref_datetime = datetime.combine(ref_date, datetime.min.time()).replace(hour=12)
+        
+        # Получаем все даты из текста
+        dates = parse_all_dates_with_duckling(text, locale="ru_RU", reference_time=ref_datetime)
+        
+        if not dates:
+            return {
+                "date": None,
+                "date_iso": None,
+                "matched_date_phrase": None,
+            }
+        
+        # Берём первую найденную дату
+        first = dates[0]
+        date_iso = first["date"]
+        
+        try:
+            parsed_date = datetime.strptime(date_iso, "%Y-%m-%d")
+            date_formatted = parsed_date.strftime("%d.%m.%Y")
+        except ValueError:
+            date_formatted = None
+        
+        return {
+            "date": date_formatted,
+            "date_iso": date_iso,
+            "matched_date_phrase": first["text"],
+        }
+    
+    def extract_all(self, text: str, reference_date: str | date | None = None) -> list[dict[str, Any]]:
+        """
+        Извлекает все даты из текста.
+        """
+        ref_datetime = None
+        if reference_date:
+            ref_date = self.to_date(reference_date)
+            ref_datetime = datetime.combine(ref_date, datetime.min.time()).replace(hour=12)
+        
+        dates = parse_all_dates_with_duckling(text, locale="ru_RU", reference_time=ref_datetime)
+        
+        results = []
+        for d in dates:
+            try:
+                parsed_date = datetime.strptime(d["date"], "%Y-%m-%d")
+                date_formatted = parsed_date.strftime("%d.%m.%Y")
+            except ValueError:
+                date_formatted = None
+            
+            results.append({
+                "date": date_formatted,
+                "date_iso": d["date"],
+                "matched_date_phrase": d["text"],
+            })
+        
+        return results
+    
+    @staticmethod
+    def to_date(value: str | date) -> date:
+        return value if isinstance(value, date) else datetime.strptime(value, "%Y-%m-%d").date()
+
+
+# Выбор парсера дат: "duckling" или "legacy" (старый код)
+DATE_PARSER_MODE = os.getenv("DATE_PARSER_MODE", "duckling")
+
+def get_date_extractor():
+    """Возвращает экстрактор дат в зависимости от настройки."""
+    if DATE_PARSER_MODE == "duckling":
+        return DucklingDateExtractor()
+    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())
+
+    def extract(self, text: str, reference_date: str | date | None = None, debug_supplier: bool = False) -> dict[str, Any]:
+        date_info = self.date_extractor.extract(text, reference_date=reference_date)
+        supplier_info = self.supplier_extractor.extract(
+            text,
+            date_phrase=date_info.get("matched_date_phrase"),
+            debug=debug_supplier,
+        )
+        user_info = self.user_extractor.extract(
+            text,
+            supplier_phrase=supplier_info.get("matched_supplier_phrase"),
+            date_phrase=date_info.get("matched_date_phrase"),
+        )
+        amount_info = self.amount_extractor.extract(
+            text,
+            matched_date_phrase=date_info["matched_date_phrase"],
+            matched_supplier_phrase=supplier_info["matched_supplier_phrase"],
+        )
+
+        result = {
+            "text": text,
+            "user": user_info["user"],
+            "supplier": supplier_info["supplier"],
+            "amount": amount_info["amount"],
+            "date": date_info["date"],
+            "date_iso": date_info["date_iso"],
+        }
+        if debug_supplier and "supplier_debug" in supplier_info:
+            result["supplier_debug"] = supplier_info["supplier_debug"]
+        return result
+
+
+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 []
+
+    names: list[str] = []
+    for item in items:
+        if isinstance(item, dict):
+            name = item.get("name")
+            if isinstance(name, str) and name.strip():
+                names.append(name.strip())
+            continue
+
+        if isinstance(item, str) and item.strip():
+            names.append(item.strip())
+
+    return names
+
+
+def polish_notes_text(text: str) -> str:
+    normalized = re.sub(r"\s+", " ", text).strip()
+    if not normalized:
+        return ""
+
+    normalized = normalized[0].upper() + normalized[1:]
+    if normalized[-1] not in ".!?":
+        normalized += "."
+
+    return normalized
+
+
+def transcribe_audio_text(audio_path: str) -> str:
+    mock_text = os.getenv("EXPENSE_VOICE_MOCK_TEXT")
+    if mock_text:
+        return mock_text.strip()
+
+    try:
+        whisper_model = get_whisper_model()
+        segments, _ = whisper_model.transcribe(audio_path, language="ru", vad_filter=True)
+        text = " ".join(segment.text.strip() for segment in segments if segment.text and segment.text.strip())
+        if text:
+            return text
+    except Exception:
+        pass
+
+    raise RuntimeError("Speech-to-text backend is unavailable. Install faster-whisper or set EXPENSE_VOICE_MOCK_TEXT.")
+
+
+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"))
+
+    transcript = transcribe_audio_text(audio_path)
+
+    if mode == "notes":
+        notes = polish_notes_text(transcript)
+        return {
+            "status": "ok",
+            "text": transcript,
+            "notes": notes,
+            "supplier": None,
+            "user": None,
+            "date": None,
+            "sum": None,
+        }
+
+    if not supplier_names:
+        raise RuntimeError("No suppliers were provided by Laravel context.")
+
+    if not user_names:
+        raise RuntimeError("No users were provided by Laravel context.")
+
+    extractor = build_default_pipeline(suppliers=supplier_names, users=user_names)
+    extracted = extractor.extract(transcript, reference_date=date.today().isoformat())
+
+    return {
+        "status": "ok",
+        "text": transcript,
+        "notes": polish_notes_text(extracted.get("text") or transcript),
+        "supplier": extracted.get("supplier"),
+        "user": extracted.get("user"),
+        "date": extracted.get("date_iso") or extracted.get("date"),
+        "sum": extracted.get("amount"),
+    }
+
+
+def require_auth():
+    expected_token = os.getenv("PYTHON_API_TOKEN", os.getenv("EXPENSE_VOICE_FASTAPI_TOKEN", "")).strip()
+
+    if not expected_token:
+        return None
+
+    authorization = request.headers.get("Authorization", "")
+    if not authorization.startswith("Bearer "):
+        return jsonify({"status": "error", "message": "Missing bearer token."}), 401
+
+    provided = authorization.removeprefix("Bearer ").strip()
+    if provided != expected_token:
+        return jsonify({"status": "error", "message": "Invalid bearer token."}), 401
+
+    return None
+
+
+def parse_context(raw: str | None) -> dict[str, Any]:
+    if not raw:
+        return {}
+
+    try:
+        payload = json.loads(raw)
+        return payload if isinstance(payload, dict) else {}
+    except json.JSONDecodeError:
+        return {}
+
+
+@app.get("/")
+def index():
+    return jsonify({
+        "status": "ok",
+        "message": "Voice processing API is running",
+        "endpoints": {
+            "POST /process-audio": "Process audio file",
+            "GET /health": "Health check"
+        }
+    })
+
+
+@app.get("/health")
+def health():
+    return jsonify({"status": "ok"})
+
+
+@app.post("/process-audio")
+def process_audio():
+    auth_error = require_auth()
+    if auth_error:
+        return auth_error
+
+    audio = request.files.get("audio")
+    mode = (request.form.get("mode") or "expense").strip()
+    context = parse_context(request.form.get("context"))
+
+    if audio is None:
+        return jsonify({"status": "error", "message": "Audio file is required."}), 422
+
+    suffix = Path(audio.filename or "voice.webm").suffix or ".webm"
+    temp_path = None
+
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+            temp_path = temp_file.name
+            audio.save(temp_file)
+
+        result = process_voice_request(audio_path=temp_path, mode=mode, payload={"context": context})
+        return jsonify(result)
+    except Exception as exception:
+        return jsonify({"status": "error", "message": str(exception)}), 422
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            os.unlink(temp_path)
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=int(os.getenv("PORT", "7860")))

duckling_client.py

@@ -0,0 +1,141 @@
+import os
+import requests
+from datetime import datetime
+from typing import Optional
+
+DUCKLING_URL = os.getenv("DUCKLING_URL", "http://localhost:8000/parse")
+
+
+def parse_date_with_duckling(
+    text: str,
+    locale: str = "ru_RU",
+    reference_time: Optional[datetime] = None
+) -> Optional[str]:
+    """
+    Извлекает дату из текста с помощью Duckling.
+    
+    Args:
+        text: Текст для парсинга (например: "завтра", "через 2 дня", "15 января 2025")
+        locale: Локаль для парсинга (ru_RU для русского)
+        reference_time: Опорное время для относительных дат (по умолчанию - сейчас)
+    
+    Returns:
+        ISO дата (YYYY-MM-DD) или None если дата не найдена
+    """
+    if reference_time is None:
+        reference_time = datetime.now()
+    
+    # Формат времени для Duckling: "2026-04-19T12:00:00+03:00"
+    ref_time_str = reference_time.strftime("%Y-%m-%dT%H:%M:%S+00:00")
+    
+    try:
+        response = requests.post(
+            DUCKLING_URL,
+            data={
+                "locale": locale,
+                "text": text,
+                "dims": '["time"]',  # Извлекаем только даты/время
+                "reftime": ref_time_str
+            },
+            timeout=5
+        )
+        response.raise_for_status()
+        results = response.json()
+        
+        if results and len(results) > 0:
+            # Берём первый найденный результат
+            value = results[0].get("value", {})
+            
+            # Duckling возвращает разные форматы
+            if "value" in value:
+                # Формат: {"value": "2026-04-20T00:00:00.000+00:00", "grain": "day"}
+                date_str = value["value"]
+                # Извлекаем только дату
+                return date_str[:10]  # "2026-04-20"
+            elif "from" in value:
+                # Интервал: {"from": {...}, "to": {...}}
+                from_value = value["from"].get("value", "")
+                return from_value[:10] if from_value else None
+        
+        return None
+        
+    except requests.RequestException as e:
+        print(f"Duckling error: {e}")
+        return None
+    except (KeyError, IndexError, ValueError) as e:
+        print(f"Duckling parse error: {e}")
+        return None
+
+
+def parse_all_dates_with_duckling(
+    text: str,
+    locale: str = "ru_RU",
+    reference_time: Optional[datetime] = None
+) -> list[dict]:
+    """
+    Извлекает все даты из текста.
+    
+    Returns:
+        Список словарей: [{"text": "завтра", "date": "2026-04-20", "start": 0, "end": 6}, ...]
+    """
+    if reference_time is None:
+        reference_time = datetime.now()
+    
+    ref_time_str = reference_time.strftime("%Y-%m-%dT%H:%M:%S+00:00")
+    
+    try:
+        response = requests.post(
+            DUCKLING_URL,
+            data={
+                "locale": locale,
+                "text": text,
+                "dims": '["time"]',
+                "reftime": ref_time_str
+            },
+            timeout=5
+        )
+        response.raise_for_status()
+        results = response.json()
+        
+        dates = []
+        for result in results:
+            value = result.get("value", {})
+            date_str = None
+            
+            if "value" in value:
+                date_str = value["value"][:10]
+            elif "from" in value:
+                from_val = value["from"].get("value", "")
+                date_str = from_val[:10] if from_val else None
+            
+            if date_str:
+                dates.append({
+                    "text": result.get("body", ""),
+                    "date": date_str,
+                    "start": result.get("start", 0),
+                    "end": result.get("end", 0)
+                })
+        
+        return dates
+        
+    except Exception as e:
+        print(f"Duckling error: {e}")
+        return []
+
+
+# Пример использования
+if __name__ == "__main__":
+    test_phrases = [
+        "завтра",
+        "через 2 дня", 
+        "на следующей неделе",
+        "15 января 2025",
+        "позавчера",
+        "в прошлый понедельник",
+        "оплата за март"
+    ]
+    
+    print("Тестирование Duckling:\n")
+    for phrase in test_phrases:
+        date = parse_date_with_duckling(phrase)
+        print(f"  '{phrase}' -> {date}")

requirements.txt

@@ -0,0 +1,12 @@
+flask==3.1.0
+gunicorn==23.0.0
+faster-whisper
+pymorphy3
+rapidfuzz
+dateparser
+iuliia
+torch
+sentence-transformers
+scikit-learn
+gliner
+requests

supervisord.conf

@@ -0,0 +1,26 @@
+[supervisord]
+nodaemon=true
+logfile=/tmp/supervisord.log
+pidfile=/tmp/supervisord.pid
+childlogdir=/tmp
+
+[program:duckling]
+command=/usr/local/bin/duckling-example-exe -p 8000
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+startsecs=3
+
+[program:gunicorn]
+command=gunicorn --bind 0.0.0.0:7860 --workers 1 --threads 8 --timeout 120 app:app
+directory=/home/user/app
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+startsecs=5