Spaces:
Sleeping
Sleeping
| """Three-mode date intelligence engine for ProjectCraft.""" | |
| import re | |
| from datetime import date, timedelta | |
| def detect_date_mode(start: str, end: str, start_ai: bool, end_ai: bool) -> str: | |
| """ | |
| Detect which date mode to use. | |
| has_start = bool(start.strip()) and not start_ai | |
| has_end = bool(end.strip()) and not end_ai | |
| Mode A: both provided -> return "A" | |
| Mode B: start only -> return "B" | |
| Mode C: end only -> return "C" | |
| Neither: raise ValueError("At least one date must be provided.") | |
| """ | |
| has_start = bool(start.strip()) and not start_ai | |
| has_end = bool(end.strip()) and not end_ai | |
| if has_start and has_end: | |
| return "A" | |
| elif has_start: | |
| return "B" | |
| elif has_end: | |
| return "C" | |
| else: | |
| raise ValueError("At least one date must be provided.") | |
| def validate_date_order(start: str, end: str) -> bool: | |
| """Return True if start <= end (both as YYYY-MM-DD strings). Return True if either is empty.""" | |
| if not start or not end: | |
| return True | |
| parsed_start = parse_iso_date(start) | |
| parsed_end = parse_iso_date(end) | |
| if parsed_start is None or parsed_end is None: | |
| return True | |
| return parsed_start <= parsed_end | |
| def format_date_range(start: str, end: str) -> str: | |
| """Format two YYYY-MM-DD strings into a readable range like 'Jan 15, 2025 -> Mar 20, 2025'. Handle None/empty gracefully.""" | |
| def fmt(d: str) -> str: | |
| if not d: | |
| return "" | |
| parsed = parse_iso_date(d) | |
| if parsed is None: | |
| return "" | |
| # strftime('%d') zero-pads; lstrip('0') gives non-padded day cross-platform | |
| day = parsed.strftime("%d").lstrip("0") or "0" | |
| return parsed.strftime(f"%b {day}, %Y") | |
| start_fmt = fmt(start) if start else "" | |
| end_fmt = fmt(end) if end else "" | |
| if start_fmt and end_fmt: | |
| return f"{start_fmt} \u2192 {end_fmt}" | |
| elif start_fmt: | |
| return start_fmt | |
| elif end_fmt: | |
| return end_fmt | |
| return "" | |
| def parse_iso_date(date_str: str): | |
| """Parse a YYYY-MM-DD string to datetime.date. Return None if invalid.""" | |
| if not date_str or not isinstance(date_str, str): | |
| return None | |
| if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", date_str.strip()): | |
| return None | |
| try: | |
| parts = date_str.strip().split("-") | |
| return date(int(parts[0]), int(parts[1]), int(parts[2])) | |
| except (ValueError, IndexError): | |
| return None | |
| def days_between(start: str, end: str) -> int: | |
| """Return number of days between two YYYY-MM-DD strings. Return 0 if either is invalid.""" | |
| parsed_start = parse_iso_date(start) | |
| parsed_end = parse_iso_date(end) | |
| if parsed_start is None or parsed_end is None: | |
| return 0 | |
| return abs((parsed_end - parsed_start).days) | |
| def offset_date(base_date: str, offset_days: int) -> str: | |
| """Add offset_days to a YYYY-MM-DD string. Return the result as YYYY-MM-DD.""" | |
| parsed = parse_iso_date(base_date) | |
| if parsed is None: | |
| raise ValueError(f"Invalid base date: {base_date!r}") | |
| result = parsed + timedelta(days=offset_days) | |
| return result.isoformat() | |