TestNatasha

natasha_dates.py

@@ -1,178 +1,514 @@
 """
-Профессиональный парсер дат для русского языка.
-Использует Natasha (DatesExtractor) - лучшее решение для русского.
-Поддерживает точные и относительные даты с морфологическим анализом.
+Универсальный парсер дат для русского языка.
+Использует собственные правила + опционально Natasha как fallback.
+Поддерживает: точные даты, относительные, порядковые числительные, числа словами.
 """
 
 import re
 from datetime import date, datetime, timedelta
-from typing import Any, Optional
+from typing import Any, Optional, Callable
 from dateutil.relativedelta import relativedelta
 
-from natasha import DatesExtractor, MorphVocab
-from natasha.extractors import Match
+# Опциональный импорт Natasha
+try:
+    from natasha import DatesExtractor, MorphVocab
+    NATASHA_AVAILABLE = True
+except ImportError:
+    NATASHA_AVAILABLE = False
+    DatesExtractor = None
+    MorphVocab = None
 
-# Инициализация Natasha
-_MORPH_VOCAB: Optional[MorphVocab] = None
-_DATES_EXTRACTOR: Optional[DatesExtractor] = None
+# Инициализация Natasha (ленивая)
+_MORPH_VOCAB = None
+_DATES_EXTRACTOR = None
 
 
-def _get_extractor() -> DatesExtractor:
-    """Ленивая инициализация экстрактора."""
+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
 
 
-# Паттерны для относительных дат (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()),
+# ============== СЛОВАРИ ==============
+
+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,
 }
 
-WEEKDAY_MAP = {
-    'понедельник': 0, 'вторник': 1, 'среду': 2, 'среда': 2,
-    'четверг': 3, 'пятницу': 4, 'пятница': 4,
-    'субботу': 5, 'суббота': 5, 'воскресенье': 6,
+# Порядковые числительные для дней
+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_CONTEXT_WORDS = re.compile(
+# Контекст прошлого/будущего
+PAST_INDICATORS = re.compile(
     r'\b(оплата|оплатил[аи]?|заплатил[аи]?|купил[аи]?|заказал[аи]?|'
-    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_weekday(text: str, reference: date, direction: str) -> Optional[date]:
-    """Парсит день недели относительно reference."""
+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 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)
+    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_relative_date(text: str, reference: date) -> Optional[tuple[date, str]]:
-    """Парсит относительные даты через регулярные выражения."""
+def _parse_quantity_relative(text: str, ref: date) -> Optional[tuple[date, str]]:
+    """Количественные: через 2 дня, 3 недели назад..."""
     text_lower = text.lower()
     
-    for pattern, handler in RELATIVE_PATTERNS.items():
-        match = re.search(pattern, text_lower, re.IGNORECASE)
+    # через 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:
-            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
+            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 _natasha_match_to_date(match: Match, reference: date) -> Optional[date]:
-    """Конвертирует результат Natasha в date."""
-    fact = match.fact
+def _parse_week_relative(text: str, ref: date) -> Optional[tuple[date, str]]:
+    """Недельные: на следующей неделе, на прошлой неделе..."""
+    text_lower = text.lower()
     
-    year = getattr(fact, 'year', None)
-    month = getattr(fact, 'month', None)
-    day = getattr(fact, 'day', None)
+    # на следующей/прошлой/этой неделе
+    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),
+    ]
     
-    # Если год не указан, берём из reference
-    if year is None:
-        year = reference.year
+    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)
     
-    # Если месяц не указан
-    if month is None:
-        return None
+    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)
     
-    # Если день не указан, берём 1-е число
-    if day is None:
-        day = 1
+    # Следующий день недели
+    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)
     
-    try:
-        return date(year, month, day)
-    except ValueError:
-        return None
+    # Этот день недели
+    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 _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_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]:
     """
-    Извлекает дату из текста с использованием Natasha.
+    Универсальный парсер дат для русского языка.
+    
+    Поддерживает:
+    - Прямые относительные: сегодня, завтра, вчера, послезавтра, позавчера
+    - Количественные: через 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": "завтра",
-            "parser": "natasha"  # или "relative" или "fallback"
-        }
+        {"date": "19.04.2026", "date_iso": "2026-04-19", "matched_date_phrase": "..."}
     """
     if reference_date is None:
         reference_date = date.today()
@@ -181,164 +517,56 @@ def parse_date_natasha(
         "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
+    # Порядок парсеров: от простых к сложным
+    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
 
 
-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.
-    Рекомендуемое решение для русск��го языка.
-    """
+    """Экстрактор дат для совместимости с 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()
-        
-        result = parse_date_natasha(text, ref)
-        # Убираем parser из результата для совместимости
-        return {
-            "date": result["date"],
-            "date_iso": result["date_iso"],
-            "matched_date_phrase": result["matched_date_phrase"],
-        }
+        return parse_date_natasha(text, ref)
     
     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]
+        # Для простоты возвращаем первый результат
+        result = self.extract(text, reference_date)
+        return [result] if result["date"] else []
 
 
 if __name__ == "__main__":
+    # Тестирование
     test_phrases = [
         "завтра",
         "через 2 дня",
+        "через два дня",
         "на следующей неделе",
         "15 января 2025",
         "позавчера",
@@ -347,9 +575,15 @@ if __name__ == "__main__":
         "5 марта",
         "купил вчера",
         "в конце месяца",
+        "пятого марта",
+        "двадцать первого января",
+        "3 недели назад",
+        "через месяц",
     ]
     
-    print("Тестирование Natasha DateExtractor:\n")
+    ref = date(2026, 4, 19)
+    print(f"Reference: {ref}\n")
+    
     for phrase in test_phrases:
-        result = parse_date_natasha(phrase)
-        print(f"  '{phrase}' -> {result['date_iso']} ({result['parser']})")
+        result = parse_date_natasha(phrase, ref)
+        print(f"  '{phrase}' -> {result['date_iso']} ({result['matched_date_phrase']})")