Create markdown_movie_release_sorter.py

tools/markdown_movie_release_sorter.py

@@ -0,0 +1,141 @@
+import re
+from datetime import datetime, date
+from typing import Any, Dict, List, Optional
+from smolagents.tools import Tool
+
+class MarkdownMovieReleaseSorterTool(Tool):
+    name = "markdown_movie_release_sorter"
+    description = (
+        "Extracts, validates, deduplicates, and chronologically sorts movie release dates "
+        "from raw markdown text or bullet points. Supports both English and Spanish date "
+        "formats, discards past dates relative to today, and outputs a countdown list."
+    )
+    inputs = {
+        "markdown_text": {
+            "type": "string",
+            "description": (
+                "Raw markdown containing movie titles and release dates (bullets, lines, or table rows). "
+                "Examples: '- 28 Years Later: June 20, 2026', 'Dune 3 | 2026-12-18 | Sci-fi', "
+                "'* Nosferatu - 25 de diciembre de 2026'."
+            ),
+        }
+    }
+    output_type = "string"
+
+    # Multilingual month mapping (English & Spanish)
+    MONTH_MAP = {
+        # English
+        "january": 1, "february": 2, "march": 3, "april": 4, "may": 5, "june": 6,
+        "july": 7, "august": 8, "september": 9, "october": 10, "november": 11, "december": 12,
+        "jan": 1, "feb": 2, "mar": 3, "apr": 4, "jun": 6, "jul": 7, "aug": 8, "sep": 9, "sept": 9, "oct": 10, "nov": 11, "dec": 12,
+        # Spanish
+        "enero": 1, "febrero": 2, "marzo": 3, "abril": 4, "mayo": 5, "junio": 6,
+        "julio": 7, "agosto": 8, "septiembre": 9, "setiembre": 9, "octubre": 10, "noviembre": 11, "diciembre": 12,
+        "ene": 1, "abr": 4, "ago": 8, "dic": 12
+    }
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.is_initialized = False
+
+    def _parse_date(self, text: str) -> Optional[date]:
+        """Tries various date patterns and returns a datetime.date object if found."""
+        # 1. ISO format: YYYY-MM-DD
+        m_iso = re.search(r"\b(20\d{2})[-/.](0[1-9]|1[0-2])[-/.](0[1-9]|[12]\d|3[01])\b", text)
+        if m_iso:
+            y, m, d = int(m_iso.group(1)), int(m_iso.group(2)), int(m_iso.group(3))
+            try:
+                return date(y, m, d)
+            except ValueError:
+                pass
+
+        # 2. European format: DD/MM/YYYY or DD-MM-YYYY
+        m_eu = re.search(r"\b(0[1-9]|[12]\d|3[01])[-/.](0[1-9]|1[0-2])[-/.](20\d{2})\b", text)
+        if m_eu:
+            d, m, y = int(m_eu.group(1)), int(m_eu.group(2)), int(m_eu.group(3))
+            try:
+                return date(y, m, d)
+            except ValueError:
+                pass
+
+        # 3. Text Month Formats: "October 24, 2026", "24 October 2026", or Spanish "24 de octubre de 2026"
+        month_names = "|".join(self.MONTH_MAP.keys())
+        
+        # Pattern A: Day Month Year (e.g., "24 October 2026" or "24 de octubre, 2026")
+        p_dmy = rf"\b(\d{{1,2}})(?:\s+de)?\s+({month_names})\b(?:\s+de)?,?\s+(20\d{{2}})\b"
+        m_dmy = re.search(p_dmy, text, re.IGNORECASE)
+        if m_dmy:
+            day = int(m_dmy.group(1))
+            month = self.MONTH_MAP[m_dmy.group(2).lower()]
+            year = int(m_dmy.group(3))
+            try:
+                return date(year, month, day)
+            except ValueError:
+                pass
+
+        # Pattern B: Month Day Year (e.g., "October 24, 2026")
+        p_mdy = rf"\b({month_names})\s+(\d{{1,2}}),?\s+(20\d{{2}})\b"
+        m_mdy = re.search(p_mdy, text, re.IGNORECASE)
+        if m_mdy:
+            month = self.MONTH_MAP[m_mdy.group(1).lower()]
+            day = int(m_mdy.group(2))
+            year = int(m_mdy.group(3))
+            try:
+                return date(year, month, day)
+            except ValueError:
+                pass
+
+        return None
+
+    def forward(self, markdown_text: str) -> str:
+        today = datetime.now().date()
+        parsed_movies: Dict[str, Dict[str, Any]] = {}
+
+        for line in markdown_text.splitlines():
+            line = line.strip()
+            # Ignore markdown table separators or empty lines
+            if not line or set(line) <= {"|", "-", " ", ":"}:
+                continue
+
+            parsed_dt = self._parse_date(line)
+            if not parsed_dt:
+                continue
+
+            # Calculate days until release
+            days_until = (parsed_dt - today).days
+            if days_until < 0:
+                continue  # Discard past releases
+
+            # Clean line markers: leading bullets, numbered items, table pipes
+            clean_line = re.sub(r"^[\s*\-•#\d.]+|[|]+$", "", line).strip()
+            # Normalize title key to prevent duplicates
+            title_key = re.sub(r"[^a-zA-Z0-9]", "", clean_line.lower()[:30])
+
+            if title_key not in parsed_movies:
+                parsed_movies[title_key] = {
+                    "text": clean_line,
+                    "date": parsed_dt,
+                    "days_until": days_until,
+                }
+
+        if not parsed_movies:
+            return (
+                f"No upcoming releases detected after today ({today.strftime('%Y-%m-%d')}). "
+                "Ensure dates are formatted with valid upcoming day, month, and year."
+            )
+
+        # Sort chronologically by date ascending
+        sorted_list = sorted(parsed_movies.values(), key=lambda x: x["date"])
+
+        output = [f"### Confirmed Upcoming Releases (Chronological from Today: {today.strftime('%Y-%m-%d')}):\n"]
+        for idx, item in enumerate(sorted_list, 1):
+            if item["days_until"] == 0:
+                countdown = "TODAY"
+            elif item["days_until"] == 1:
+                countdown = "Tomorrow"
+            else:
+                countdown = f"in {item['days_until']} days"
+
+            output.append(f"{idx}. [{item['date'].strftime('%Y-%m-%d')}] {item['text']} — **({countdown})**")
+
+        return "\n".join(output)