ReplacedDucklingWithNatasha

Dockerfile

@@ -1,26 +1,21 @@
-FROM rasa/duckling:latest AS duckling
 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
+    DATE_PARSER_MODE=natasha
 
-RUN echo "deb http://deb.debian.org/debian bullseye main" > /etc/apt/sources.list.d/bullseye.list \
-    && apt-get update && apt-get install -y --no-install-recommends \
-       ffmpeg supervisor libgmp10 libpcre3 libssl1.1 \
-    && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/bullseye.list \
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg \
+    && rm -rf /var/lib/apt/lists/* \
     && useradd -m -u 1000 user
 
-COPY --from=duckling /usr/local/bin/duckling-example-exe /usr/local/bin/
-
 USER user
 WORKDIR /home/user/app
 
 COPY --chown=user requirements.txt .
 RUN pip install --upgrade pip && pip install -r requirements.txt
 
-COPY --chown=user app.py duckling_client.py supervisord.conf ./
+COPY --chown=user app.py natasha_dates.py ./
 
 EXPOSE 7860
-CMD ["supervisord", "-c", "supervisord.conf"]
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "4", "--timeout", "120", "app:app"]

app.py

@@ -24,8 +24,8 @@ 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
+# Natasha - лучший парсер дат для русского языка (работает локально)
+from natasha_dates import NatashaDateExtractor, parse_date_natasha
 
 # HuggingFace Token (если нужен для моделей)
 HF_TOKEN = os.getenv("HF_TOKEN")
@@ -590,97 +590,17 @@ class ExpenseDateExtractor:
         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")
+# Парсер дат: "natasha" (рекомендуется) или "legacy"
+DATE_PARSER_MODE = os.getenv("DATE_PARSER_MODE", "natasha")
 
 def get_date_extractor():
-    """Возвращает экстрактор дат в зависимости от настройки."""
-    if DATE_PARSER_MODE == "duckling":
-        return DucklingDateExtractor()
+    """
+    Возвращает экстрактор дат.
+    - natasha: Лучший для русского языка (по умолчанию)
+    - legacy: Старый код ExpenseDateExtractor
+    """
+    if DATE_PARSER_MODE == "natasha":
+        return NatashaDateExtractor()
     return ExpenseDateExtractor()
 
 
@@ -1241,10 +1161,11 @@ def index():
     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",
-            "GET /duckling-test": "Test Duckling date parsing"
+            "GET /date-test": "Test date parsing"
         }
     })
 
@@ -1254,9 +1175,9 @@ def health():
     return jsonify({"status": "ok"})
 
 
-@app.get("/duckling-test")
-def duckling_test():
-    """Тестирование Duckling - парсинг дат из текста."""
+@app.get("/date-test")
+def date_test():
+    """Тестирование парсера дат (использует текущий DATE_PARSER_MODE)."""
     test_phrases = [
         "завтра",
         "через 2 дня",
@@ -1264,17 +1185,26 @@ def duckling_test():
         "15 января 2025",
         "позавчера",
         "в прошлый понедельник",
-        "оплата за март"
+        "оплата за март",
+        "5 марта",
+        "купил вчера",
+        "в конце месяца"
     ]
     
+    extractor = get_date_extractor()
     results = []
     for phrase in test_phrases:
-        date_result = parse_date_with_duckling(phrase)
-        results.append({"phrase": phrase, "date": date_result})
+        result = extractor.extract(phrase)
+        results.append({
+            "phrase": phrase, 
+            "date": result.get("date_iso"),
+            "matched": result.get("matched_date_phrase")
+        })
     
     return jsonify({
         "status": "ok",
-        "duckling_url": os.getenv("DUCKLING_URL", "http://localhost:8000/parse"),
+        "parser": DATE_PARSER_MODE,
+        "reference_date": date.today().isoformat(),
         "results": results
     })
 

duckling_client.py

@@ -1,129 +0,0 @@
-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,
-    timezone: str = "Europe/Moscow"
-) -> Optional[str]:
-    """
-    Извлекает дату из текста с помощью Duckling.
-    
-    Args:
-        text: Текст для парсинга (например: "завтра", "через 2 дня", "15 января 2025")
-        locale: Локаль для парсинга (ru_RU для русского)
-        reference_time: Опорное время для относительных дат (по умолчанию - сейчас)
-        timezone: Часовой пояс
-    
-    Returns:
-        ISO дата (YYYY-MM-DD) или None если дата не найдена
-    """
-    if reference_time is None:
-        reference_time = datetime.now()
-    
-    # Duckling требует Unix timestamp в миллисекундах
-    ref_time_ms = int(reference_time.timestamp() * 1000)
-    
-    try:
-        response = requests.post(
-            DUCKLING_URL,
-            data={
-                "locale": locale,
-                "text": text,
-                "dims": '["time"]',
-                "reftime": ref_time_ms,
-                "tz": timezone
-            },
-            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,
-    timezone: str = "Europe/Moscow"
-) -> list[dict]:
-    """
-    Извлекает все даты из текста.
-    
-    Returns:
-        Список словарей: [{"text": "завтра", "date": "2026-04-20", "start": 0, "end": 6}, ...]
-    """
-    if reference_time is None:
-        reference_time = datetime.now()
-    
-    # Duckling требует Unix timestamp в миллисекундах
-    ref_time_ms = int(reference_time.timestamp() * 1000)
-    
-    try:
-        response = requests.post(
-            DUCKLING_URL,
-            data={
-                "locale": locale,
-                "text": text,
-                "dims": '["time"]',
-                "reftime": ref_time_ms,
-                "tz": timezone
-            },
-            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 []

natasha_dates.py

@@ -0,0 +1,355 @@
+"""
+Профессиональный парсер дат для русского языка.
+Использует Natasha (DatesExtractor) - лучшее решение для русского.
+Поддерживает точные и относительные даты с морфологическим анализом.
+"""
+
+import re
+from datetime import date, datetime, timedelta
+from typing import Any, Optional
+from dateutil.relativedelta import relativedelta
+
+from natasha import DatesExtractor, MorphVocab
+from natasha.extractors import Match
+
+# Инициализация Natasha
+_MORPH_VOCAB: Optional[MorphVocab] = None
+_DATES_EXTRACTOR: Optional[DatesExtractor] = None
+
+
+def _get_extractor() -> DatesExtractor:
+    """Ленивая инициализация экстрактора."""
+    global _MORPH_VOCAB, _DATES_EXTRACTOR
+    if _DATES_EXTRACTOR is None:
+        _MORPH_VOCAB = MorphVocab()
+        _DATES_EXTRACTOR = DatesExtractor(_MORPH_VOCAB)
+    return _DATES_EXTRACTOR
+
+
+# Паттерны для относительных дат (Natasha не всегда их распознаёт)
+RELATIVE_PATTERNS = {
+    # Простые относительные
+    r'\bсегодня\b': lambda ref: ref,
+    r'\bзавтра\b': lambda ref: ref + timedelta(days=1),
+    r'\bпослезавтра\b': lambda ref: ref + timedelta(days=2),
+    r'\bвчера\b': lambda ref: ref - timedelta(days=1),
+    r'\bпозавчера\b': lambda ref: ref - timedelta(days=2),
+    
+    # "через X дней/недель/месяцев"
+    r'\bчерез\s+(\d+)\s+(?:день|дня|дней)\b': lambda ref, n: ref + timedelta(days=int(n)),
+    r'\bчерез\s+(\d+)\s+(?:неделю|недели|недель)\b': lambda ref, n: ref + timedelta(weeks=int(n)),
+    r'\bчерез\s+(\d+)\s+(?:месяц|месяца|месяцев)\b': lambda ref, n: ref + relativedelta(months=int(n)),
+    
+    # "X дней/недель/месяцев назад"
+    r'\b(\d+)\s+(?:день|дня|дней)\s+назад\b': lambda ref, n: ref - timedelta(days=int(n)),
+    r'\b(\d+)\s+(?:неделю|недели|недель)\s+назад\b': lambda ref, n: ref - timedelta(weeks=int(n)),
+    r'\b(\d+)\s+(?:месяц|месяца|месяцев)\s+назад\b': lambda ref, n: ref - relativedelta(months=int(n)),
+    
+    # Дни недели
+    r'\b(?:в\s+)?(?:прошлый|прошлую)\s+(понедельник|вторник|среду|четверг|пятницу|субботу|воскресенье)\b': 'past_weekday',
+    r'\b(?:в\s+)?(?:следующий|следующую|этот|эту)\s+(понедельник|вторник|среду|четверг|пятницу|субботу|воскресенье)\b': 'next_weekday',
+    
+    # Недели
+    r'\b(?:на\s+)?(?:прошлой|прошлую)\s+неделю?\b': lambda ref: ref - timedelta(weeks=1),
+    r'\b(?:на\s+)?(?:следующей|следующую)\s+неделю?\b': lambda ref: ref + timedelta(weeks=1),
+    r'\b(?:на\s+)?этой\s+неделе\b': lambda ref: ref,
+    
+    # Начало/конец периода
+    r'\b(?:в\s+)?начал[еоа]\s+месяца\b': lambda ref: ref.replace(day=1),
+    r'\b(?:в\s+)?конц[еа]\s+месяца\b': lambda ref: (ref.replace(day=1) + relativedelta(months=1) - timedelta(days=1)),
+    r'\b(?:в\s+)?начал[еоа]\s+недели\b': lambda ref: ref - timedelta(days=ref.weekday()),
+    r'\b(?:в\s+)?конц[еа]\s+недели\b': lambda ref: ref + timedelta(days=6-ref.weekday()),
+}
+
+WEEKDAY_MAP = {
+    'понедельник': 0, 'вторник': 1, 'среду': 2, 'среда': 2,
+    'четверг': 3, 'пятницу': 4, 'пятница': 4,
+    'субботу': 5, 'суббота': 5, 'воскресенье': 6,
+}
+
+# Индикаторы прошедшего времени для контекстной коррекции
+PAST_CONTEXT_WORDS = re.compile(
+    r'\b(оплата|оплатил[аи]?|заплатил[аи]?|купил[аи]?|заказал[аи]?|'
+    r'потратил[аи]?|был[аио]?|получил[аи]?|сделал[аи]?)\b',
+    re.IGNORECASE
+)
+
+
+def _parse_weekday(text: str, reference: date, direction: str) -> Optional[date]:
+    """Парсит день недели относительно reference."""
+    text_lower = text.lower()
+    for name, weekday_num in WEEKDAY_MAP.items():
+        if name in text_lower:
+            days_diff = weekday_num - reference.weekday()
+            if direction == 'past_weekday':
+                if days_diff >= 0:
+                    days_diff -= 7
+            else:  # next_weekday
+                if days_diff <= 0:
+                    days_diff += 7
+            return reference + timedelta(days=days_diff)
+    return None
+
+
+def _parse_relative_date(text: str, reference: date) -> Optional[tuple[date, str]]:
+    """Парсит относительные даты через регулярные выражения."""
+    text_lower = text.lower()
+    
+    for pattern, handler in RELATIVE_PATTERNS.items():
+        match = re.search(pattern, text_lower, re.IGNORECASE)
+        if match:
+            matched_text = match.group(0)
+            
+            if handler == 'past_weekday':
+                result = _parse_weekday(matched_text, reference, 'past_weekday')
+            elif handler == 'next_weekday':
+                result = _parse_weekday(matched_text, reference, 'next_weekday')
+            elif callable(handler):
+                groups = match.groups()
+                if groups:
+                    result = handler(reference, groups[0])
+                else:
+                    result = handler(reference)
+            else:
+                continue
+            
+            if result:
+                return result, matched_text
+    
+    return None
+
+
+def _natasha_match_to_date(match: Match, reference: date) -> Optional[date]:
+    """Конвертирует результат Natasha в date."""
+    fact = match.fact
+    
+    year = getattr(fact, 'year', None)
+    month = getattr(fact, 'month', None)
+    day = getattr(fact, 'day', None)
+    
+    # Если год не указан, берём из reference
+    if year is None:
+        year = reference.year
+    
+    # Если месяц не указан
+    if month is None:
+        return None
+    
+    # Если день не указан, берём 1-е число
+    if day is None:
+        day = 1
+    
+    try:
+        return date(year, month, day)
+    except ValueError:
+        return None
+
+
+def _adjust_date_by_context(parsed_date: date, text: str, reference: date) -> date:
+    """
+    Корректирует дату по контексту.
+    Если есть индикаторы прошлого и дата в будущем - сдвигаем на год назад.
+    """
+    if PAST_CONTEXT_WORDS.search(text) and parsed_date > reference:
+        return parsed_date - relativedelta(years=1)
+    return parsed_date
+
+
+def parse_date_natasha(
+    text: str,
+    reference_date: Optional[date] = None
+) -> dict[str, Any]:
+    """
+    Извлекает дату из текста с использованием Natasha.
+    
+    Args:
+        text: Текст для анализа
+        reference_date: Опорная дата (по умолчанию - сегодня)
+    
+    Returns:
+        {
+            "date": "19.04.2026",
+            "date_iso": "2026-04-19", 
+            "matched_date_phrase": "завтра",
+            "parser": "natasha"  # или "relative" или "fallback"
+        }
+    """
+    if reference_date is None:
+        reference_date = date.today()
+    
+    result = {
+        "date": None,
+        "date_iso": None,
+        "matched_date_phrase": None,
+        "parser": None
+    }
+    
+    # 1. Сначала пробуем относительные паттерны (они надёжнее для "завтра", "через 2 дня")
+    relative_result = _parse_relative_date(text, reference_date)
+    if relative_result:
+        parsed_date, matched = relative_result
+        parsed_date = _adjust_date_by_context(parsed_date, text, reference_date)
+        result["date"] = parsed_date.strftime("%d.%m.%Y")
+        result["date_iso"] = parsed_date.isoformat()
+        result["matched_date_phrase"] = matched
+        result["parser"] = "relative"
+        return result
+    
+    # 2. Затем пробуем Natasha для точных дат ("15 января 2025", "5 марта")
+    try:
+        extractor = _get_extractor()
+        matches = list(extractor(text))
+        
+        if matches:
+            # Берём первый результат
+            match = matches[0]
+            parsed_date = _natasha_match_to_date(match, reference_date)
+            
+            if parsed_date:
+                parsed_date = _adjust_date_by_context(parsed_date, text, reference_date)
+                result["date"] = parsed_date.strftime("%d.%m.%Y")
+                result["date_iso"] = parsed_date.isoformat()
+                result["matched_date_phrase"] = text[match.start:match.stop]
+                result["parser"] = "natasha"
+                return result
+    except Exception as e:
+        print(f"Natasha error: {e}")
+    
+    # 3. Fallback: ищем месяц без дня ("за март", "за апрель")
+    month_pattern = re.compile(
+        r'\b(?:за|в|на)\s+(январ[ья]|феврал[ья]|март[а]?|апрел[ья]|ма[йя]|июн[ья]|'
+        r'июл[ья]|август[а]?|сентябр[ья]|октябр[ья]|ноябр[ья]|декабр[ья])\b',
+        re.IGNORECASE
+    )
+    month_match = month_pattern.search(text)
+    if month_match:
+        month_names = {
+            'январ': 1, 'феврал': 2, 'март': 3, 'апрел': 4, 'ма': 5, 'июн': 6,
+            'июл': 7, 'август': 8, 'сентябр': 9, 'октябр': 10, 'ноябр': 11, 'декабр': 12
+        }
+        month_text = month_match.group(1).lower()
+        for prefix, month_num in month_names.items():
+            if month_text.startswith(prefix):
+                # Определяем год по контексту
+                year = reference_date.year
+                # Если месяц > текущего и есть индикаторы прошлого - прошлый год
+                if month_num > reference_date.month and PAST_CONTEXT_WORDS.search(text):
+                    year -= 1
+                # Если месяц < текущего и нет индикаторов прошлого - этот год
+                elif month_num < reference_date.month and not PAST_CONTEXT_WORDS.search(text):
+                    pass  # оставляем текущий год
+                
+                try:
+                    parsed_date = date(year, month_num, 1)
+                    result["date"] = parsed_date.strftime("%d.%m.%Y")
+                    result["date_iso"] = parsed_date.isoformat()
+                    result["matched_date_phrase"] = month_match.group(0)
+                    result["parser"] = "fallback_month"
+                    return result
+                except ValueError:
+                    pass
+                break
+    
+    return result
+
+
+def parse_all_dates_natasha(
+    text: str,
+    reference_date: Optional[date] = None
+) -> list[dict[str, Any]]:
+    """Извлекает все даты из текста."""
+    if reference_date is None:
+        reference_date = date.today()
+    
+    results = []
+    
+    # Natasha matches
+    try:
+        extractor = _get_extractor()
+        for match in extractor(text):
+            parsed_date = _natasha_match_to_date(match, reference_date)
+            if parsed_date:
+                parsed_date = _adjust_date_by_context(parsed_date, text, reference_date)
+                results.append({
+                    "date": parsed_date.strftime("%d.%m.%Y"),
+                    "date_iso": parsed_date.isoformat(),
+                    "matched_date_phrase": text[match.start:match.stop],
+                    "start": match.start,
+                    "end": match.stop,
+                    "parser": "natasha"
+                })
+    except Exception as e:
+        print(f"Natasha error: {e}")
+    
+    # Relative dates
+    relative_result = _parse_relative_date(text, reference_date)
+    if relative_result:
+        parsed_date, matched = relative_result
+        parsed_date = _adjust_date_by_context(parsed_date, text, reference_date)
+        # Проверяем что не дубликат
+        if not any(r["date_iso"] == parsed_date.isoformat() for r in results):
+            results.append({
+                "date": parsed_date.strftime("%d.%m.%Y"),
+                "date_iso": parsed_date.isoformat(),
+                "matched_date_phrase": matched,
+                "start": text.lower().find(matched.lower()),
+                "end": text.lower().find(matched.lower()) + len(matched),
+                "parser": "relative"
+            })
+    
+    return results
+
+
+# Для обратной совместимости
+class NatashaDateExtractor:
+    """
+    Экстрактор дат на основе Natasha.
+    Рекомендуемое решение для русского языка.
+    """
+    
+    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()
+        
+        result = parse_date_natasha(text, ref)
+        # Убираем parser из результата для совместимости
+        return {
+            "date": result["date"],
+            "date_iso": result["date_iso"],
+            "matched_date_phrase": result["matched_date_phrase"],
+        }
+    
+    def extract_all(self, text: str, reference_date: Optional[date] = None) -> list[dict[str, Any]]:
+        """Извлекает все даты из текста."""
+        ref = reference_date or date.today()
+        if isinstance(ref, str):
+            ref = datetime.strptime(ref, "%Y-%m-%d").date()
+        
+        results = parse_all_dates_natasha(text, ref)
+        return [{
+            "date": r["date"],
+            "date_iso": r["date_iso"],
+            "matched_date_phrase": r["matched_date_phrase"],
+        } for r in results]
+
+
+if __name__ == "__main__":
+    test_phrases = [
+        "завтра",
+        "через 2 дня",
+        "на следующей неделе",
+        "15 января 2025",
+        "позавчера",
+        "в прошлый понедельник",
+        "оплата за март",
+        "5 марта",
+        "купил вчера",
+        "в конце месяца",
+    ]
+    
+    print("Тестирование Natasha DateExtractor:\n")
+    for phrase in test_phrases:
+        result = parse_date_natasha(phrase)
+        print(f"  '{phrase}' -> {result['date_iso']} ({result['parser']})")

requirements.txt

@@ -4,9 +4,10 @@ faster-whisper
 pymorphy3
 rapidfuzz
 dateparser
+python-dateutil
 iuliia
 torch
 sentence-transformers
 scikit-learn
 gliner
-requests
+natasha

supervisord.conf

@@ -1,26 +0,0 @@
-[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