microsoft-todo-cli 1.0.0__py3-none-any.whl

todocli/models/checklistitem.py

@@ -0,0 +1,59 @@
+from datetime import datetime, timezone
+
+
+def _parse_datetime(dt_str):
+    """Parse datetime string from checklist items API.
+
+    The checklistItems endpoint returns datetimes without fractional seconds
+    (e.g. "2026-02-04T19:08:45Z"), unlike tasks which include 7 digits
+    (e.g. "2024-01-25T10:00:00.0000000Z").
+    """
+    if dt_str is None:
+        return None
+
+    if isinstance(dt_str, dict):
+        dt_str = dt_str["dateTime"]
+
+    # Strip trailing Z
+    dt_str = dt_str.rstrip("Z")
+
+    # Truncate fractional seconds to 6 digits (Python's %f limit)
+    if "." in dt_str:
+        base, frac = dt_str.rsplit(".", 1)
+        dt_str = f"{base}.{frac[:6]}"
+
+    for fmt in ("%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"):
+        try:
+            dt = datetime.strptime(dt_str, fmt)
+            return dt.replace(tzinfo=timezone.utc).astimezone(tz=None)
+        except ValueError:
+            continue
+
+    return None
+
+
+class ChecklistItem:
+    def __init__(self, query_result):
+        self.id: str = query_result["id"]
+        self.display_name: str = query_result["displayName"]
+        self.is_checked: bool = bool(query_result["isChecked"])
+        self.created_datetime = _parse_datetime(query_result["createdDateTime"])
+
+        if "checkedDateTime" in query_result and query_result["checkedDateTime"]:
+            self.checked_datetime = _parse_datetime(query_result["checkedDateTime"])
+        else:
+            self.checked_datetime = None
+
+    def to_dict(self):
+        """Convert checklist item to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "display_name": self.display_name,
+            "is_checked": self.is_checked,
+            "created_datetime": (
+                self.created_datetime.isoformat() if self.created_datetime else None
+            ),
+            "checked_datetime": (
+                self.checked_datetime.isoformat() if self.checked_datetime else None
+            ),
+        }

todocli/models/todolist.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+
+class TodoList:
+    class WellKnownListName(Enum):
+        none = "none"
+        DefaultList = "defaultList"
+        FlaggedEmails = "flaggedEmails"
+
+    def __init__(self, query_result_list):
+        self.id: str = query_result_list["id"]
+        self.display_name: str = query_result_list["displayName"]
+        self.is_owner = bool(query_result_list["isOwner"])
+        self.is_shared = bool(query_result_list["isShared"])
+        self.well_known_list_name = TodoList.WellKnownListName(
+            query_result_list["wellknownListName"]
+        )
+
+    def to_dict(self):
+        """Convert list to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "display_name": self.display_name,
+            "is_owner": self.is_owner,
+            "is_shared": self.is_shared,
+            "well_known_list_name": self.well_known_list_name.value,
+        }

todocli/models/todotask.py

@@ -0,0 +1,105 @@
+from enum import Enum
+from todocli.utils.datetime_util import api_timestamp_to_datetime
+
+
+class TaskStatus(str, Enum):
+    COMPLETED = "completed"
+    NOT_STARTED = "notStarted"
+    IN_PROGRESS = "inProgress"
+    WAITING_ON_OTHERS = "waitingOnOthers"
+    DEFERRED = "deferred"
+
+
+class TaskImportance(str, Enum):
+    LOW = "low"
+    NORMAL = "normal"
+    HIGH = "high"
+
+
+class RecurrencePatternType(str, Enum):
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    ABSOLUTE_MONTHLY = "absoluteMonthly"
+    RELATIVE_MONTHLY = "relativeMonthly"
+    ABSOLUTE_YEARLY = "absoluteYearly"
+    RELATIVE_YEARLY = "relativeYearly"
+
+
+class DayOfWeek(str, Enum):
+    MONDAY = "monday"
+    TUESDAY = "tuesday"
+    WEDNESDAY = "wednesday"
+    THURSDAY = "thursday"
+    FRIDAY = "friday"
+    SATURDAY = "saturday"
+    SUNDAY = "sunday"
+
+
+class Task:
+    def __init__(self, query_result):
+        self.title = query_result["title"]
+        self.id = query_result["id"]
+        self.importance = TaskImportance(query_result["importance"])
+        self.status = TaskStatus(query_result["status"])
+        self.created_datetime = api_timestamp_to_datetime(
+            query_result["createdDateTime"]
+        )
+
+        if "completedDateTime" in query_result:
+            self.completed_datetime = api_timestamp_to_datetime(
+                query_result["completedDateTime"]
+            )
+        else:
+            self.completed_datetime = None
+
+        self.is_reminder_on: bool = bool(query_result["isReminderOn"])
+
+        if "dueDateTime" in query_result:
+            self.due_datetime = api_timestamp_to_datetime(query_result["dueDateTime"])
+        else:
+            self.due_datetime = None
+
+        if "reminderDateTime" in query_result:
+            self.reminder_datetime = api_timestamp_to_datetime(
+                query_result["reminderDateTime"]
+            )
+        else:
+            self.reminder_datetime = None
+
+        self.last_modified_datetime = api_timestamp_to_datetime(
+            query_result["lastModifiedDateTime"]
+        )
+
+        if "bodyLastModifiedDateTime" in query_result:
+            self.body_last_modified_datetime = api_timestamp_to_datetime(
+                query_result["bodyLastModifiedDateTime"]
+            )
+        else:
+            self.body_last_modified_datetime = None
+
+    def to_dict(self):
+        """Convert task to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "status": self.status.value,
+            "importance": self.importance.value,
+            "is_reminder_on": self.is_reminder_on,
+            "created_datetime": (
+                self.created_datetime.isoformat() if self.created_datetime else None
+            ),
+            "due_datetime": (
+                self.due_datetime.isoformat() if self.due_datetime else None
+            ),
+            "reminder_datetime": (
+                self.reminder_datetime.isoformat() if self.reminder_datetime else None
+            ),
+            "completed_datetime": (
+                self.completed_datetime.isoformat() if self.completed_datetime else None
+            ),
+            "last_modified_datetime": (
+                self.last_modified_datetime.isoformat()
+                if self.last_modified_datetime
+                else None
+            ),
+        }

todocli/utils/datetime_util.py

@@ -0,0 +1,321 @@
+import re
+from datetime import datetime, timedelta, timezone
+from typing import Union
+
+
+class TimeExpressionNotRecognized(Exception):
+    def __init__(self, time_str):
+        self.message = (
+            f"Time expression could not be parsed: {time_str}\n"
+            f"Supported formats: 1h, 30m, 9am, 5:30pm, 17:00, tomorrow, monday, mon, "
+            f"DD.MM.YYYY, YYYY-MM-DD, MM/DD/YYYY"
+        )
+        super(TimeExpressionNotRecognized, self).__init__(self.message)
+
+
+class ErrorParsingTime(Exception):
+    def __init__(self, message):
+        self.message = message
+        super(ErrorParsingTime, self).__init__(message)
+
+
+def parse_hour_minute(input_str):
+    split_str = input_str.split(":")
+    hour = int(split_str[0])
+    minute = int(split_str[1])
+    return hour, minute
+
+
+def parse_day_month_DD_MM(input_str):
+    split_str = input_str.split(".")
+    day = int(split_str[0])
+    month = int(split_str[1])
+    return day, month
+
+
+def parse_day_month_MM_DD(input_str):
+    split_str = input_str.split("/")
+    month = int(split_str[0])
+    day = int(split_str[1])
+    return day, month
+
+
+def parse_day_month_DD_MM_YYorYYYY(input_str):
+    split_str = input_str.split(".")
+    day = int(split_str[0])
+    month = int(split_str[1])
+    year = split_str[2]
+    if len(year) == 2:
+        year = int("20" + year)
+    else:
+        year = int(year)
+    return day, month, year
+
+
+def add_day_if_past(dt: datetime) -> datetime:
+    """This function will add a day to the datetime object 'dt' when 'dt' is in the past"""
+    dt_now = datetime.now()
+    if dt < dt_now:
+        return dt + timedelta(days=1)
+    else:
+        return dt
+
+
+def parse_datetime(datetime_str: str):
+    try:
+        if match := re.match(
+            r"(?:(\d+)/(\d+)/)?(\d+d)?(\d+h)?(\d+m)?(\d+s)?$",
+            datetime_str,
+            re.IGNORECASE,
+        ):
+            """e.g. 1h / 12h"""
+            multiplier = 1
+            if match.group(1):
+                multiplier = int(match.group(2)) - int(match.group(1))
+            return (
+                datetime.now()
+                + timedelta(
+                    days=0 if match.group(3) is None else int(match.group(3)[:-1]),
+                    hours=0 if match.group(4) is None else int(match.group(4)[:-1]),
+                    minutes=0 if match.group(5) is None else int(match.group(5)[:-1]),
+                    seconds=0 if match.group(6) is None else int(match.group(6)[:-1]),
+                )
+                * multiplier
+            )
+
+        if datetime_str == "morning":
+            dt = datetime.now()
+            return add_day_if_past(
+                dt.replace(hour=7, minute=0, second=0, microsecond=0)
+            )
+
+        if datetime_str == "tomorrow":
+            dt = datetime.now()
+            return dt.replace(hour=7, minute=0, second=0, microsecond=0) + timedelta(
+                days=1
+            )
+
+        if datetime_str == "evening":
+            dt = datetime.now()
+            return add_day_if_past(
+                dt.replace(hour=18, minute=0, second=0, microsecond=0)
+            )
+
+        # Day names (monday, mon, tuesday, tue, etc.)
+        day_names = {
+            "monday": 0, "mon": 0,
+            "tuesday": 1, "tue": 1,
+            "wednesday": 2, "wed": 2,
+            "thursday": 3, "thu": 3,
+            "friday": 4, "fri": 4,
+            "saturday": 5, "sat": 5,
+            "sunday": 6, "sun": 6,
+        }
+        if datetime_str.lower() in day_names:
+            target_weekday = day_names[datetime_str.lower()]
+            dt = datetime.now()
+            current_weekday = dt.weekday()
+            days_ahead = target_weekday - current_weekday
+            if days_ahead <= 0:  # Target day already happened this week
+                days_ahead += 7
+            return (dt + timedelta(days=days_ahead)).replace(
+                hour=7, minute=0, second=0, microsecond=0
+            )
+
+        # Time without space: 9am, 5pm, 5:30pm, 10:30am
+        if match := re.match(r"^(\d{1,2})(?::(\d{2}))?(am|pm)$", datetime_str, re.IGNORECASE):
+            hour = int(match.group(1))
+            minute = int(match.group(2)) if match.group(2) else 0
+            is_pm = match.group(3).lower() == "pm"
+
+            if is_pm and hour != 12:
+                hour += 12
+            elif not is_pm and hour == 12:
+                hour = 0
+
+            return add_day_if_past(
+                datetime.now().replace(
+                    hour=hour, minute=minute, second=0, microsecond=0
+                )
+            )
+
+        if re.match(r"([0-9]{1,2}:[0-9]{2} (am|pm))", datetime_str, re.IGNORECASE):
+            """e.g. 5:30 pm"""
+            split_str = datetime_str.split(" ")
+            hour, minute = parse_hour_minute(split_str[0])
+
+            if split_str[1].lower() == "am":
+                if hour == 12:
+                    hour = 0
+            else:
+                if hour != 12:
+                    hour = hour + 12
+
+            return add_day_if_past(
+                datetime.now().replace(
+                    hour=hour, minute=minute, second=0, microsecond=0
+                )
+            )
+
+        if re.match(r"([0-9]{1,2}:[0-9]{2})", datetime_str, re.IGNORECASE):
+            """e.g. 17:00"""
+            hour, minute = parse_hour_minute(datetime_str)
+            return add_day_if_past(
+                datetime.now().replace(
+                    hour=hour, minute=minute, second=0, microsecond=0
+                )
+            )
+
+        if re.match(
+            r"([0-9]{1,2}\.[0-9]{1,2}\.(([0-9]{4})|([0-9]{2})))$",
+            datetime_str,
+            re.IGNORECASE,
+        ):
+            """e.g. 17.01.20 or 22.12.2020"""
+            day, month, year = parse_day_month_DD_MM_YYorYYYY(datetime_str)
+            return datetime.now().replace(
+                year=year,
+                day=day,
+                month=month,
+                hour=7,
+                minute=0,
+                second=0,
+                microsecond=0,
+            )
+
+        if re.match(r"\d{4}-\d{1,2}-\d{1,2}$", datetime_str):
+            """e.g. 2026-02-11 or 2026-2-11 (ISO 8601)"""
+            parts = datetime_str.split("-")
+            year = int(parts[0])
+            month = int(parts[1])
+            day = int(parts[2])
+            return datetime.now().replace(
+                year=year,
+                day=day,
+                month=month,
+                hour=7,
+                minute=0,
+                second=0,
+                microsecond=0,
+            )
+
+        if re.match(
+            r"([0-9]{1,2}/[0-9]{1,2}/(([0-9]{4})|([0-9]{2})))$",
+            datetime_str,
+        ):
+            """e.g. 02/11/2026 or 02/11/26 (US date, MM/DD/YYYY)"""
+            parts = datetime_str.split("/")
+            month = int(parts[0])
+            day = int(parts[1])
+            year_str = parts[2]
+            year = int("20" + year_str) if len(year_str) == 2 else int(year_str)
+            return datetime.now().replace(
+                year=year,
+                day=day,
+                month=month,
+                hour=7,
+                minute=0,
+                second=0,
+                microsecond=0,
+            )
+
+        if re.match(
+            r"([0-9]{1,2}\.[0-9]{1,2}\. [0-9]{1,2}:[0-9]{2})",
+            datetime_str,
+            re.IGNORECASE,
+        ):
+            """e.g. 17.01. 17:00"""
+            split_str = datetime_str.split(" ")
+            day, month = parse_day_month_DD_MM(split_str[0])
+            hour, minute = parse_hour_minute(split_str[1])
+            return datetime.now().replace(
+                day=day, month=month, hour=hour, minute=minute, second=0, microsecond=0
+            )
+
+        if re.match(
+            r"([0-9]{1,2}/[0-9]{1,2} [0-9]{1,2}:[0-9]{2} (am|pm))",
+            datetime_str,
+            re.IGNORECASE,
+        ):
+            """e.g. 01/17 5:00 pm"""
+            split_str = datetime_str.split(" ")
+            day, month = parse_day_month_MM_DD(split_str[0])
+            hour, minute = parse_hour_minute(split_str[1])
+
+            if split_str[2].lower() == "am":
+                if hour == 12:
+                    hour = 0
+            else:
+                if hour != 12:
+                    hour = hour + 12
+
+            return datetime.now().replace(
+                day=day, month=month, hour=hour, minute=minute, second=0, microsecond=0
+            )
+
+    except ValueError as e:
+        raise ErrorParsingTime(str(e))
+
+    raise TimeExpressionNotRecognized(datetime_str)
+
+
+def format_date(dt: datetime, fmt: str = "eu") -> str:
+    if fmt == "iso":
+        return dt.strftime("%Y-%m-%d")
+    elif fmt == "us":
+        return dt.strftime("%m/%d/%Y")
+    else:
+        return dt.strftime("%d.%m.%Y")
+
+
+def datetime_to_api_timestamp(dt: datetime | None):
+    if dt is None:
+        return None
+
+    utc_dt = dt.astimezone(timezone.utc)
+    timestamp_str = utc_dt.strftime("%Y-%m-%dT%H:%M:%S")
+
+    api_dt = {"dateTime": timestamp_str, "timeZone": "UTC"}
+    return api_dt
+
+
+def api_timestamp_to_datetime(api_dt: Union[str, dict]):
+    """Converts the datetime string returned by the API to python datetime object.
+
+    Handles various timestamp formats from Microsoft Graph API:
+    - With 7-digit microseconds: "2024-01-25T10:00:00.0000000Z"
+    - Without microseconds: "2024-01-25T10:00:00Z"
+    - Dict format: {"dateTime": "...", "timeZone": "UTC"}
+    """
+    if api_dt is None:
+        return None
+
+    # Extract the datetime string
+    if isinstance(api_dt, str):
+        dt_str = api_dt
+    elif isinstance(api_dt, dict):
+        dt_str = api_dt.get("dateTime", "")
+    else:
+        raise TypeError(f"Expected str or dict, got {type(api_dt).__name__}")
+
+    # Strip trailing Z
+    dt_str = dt_str.rstrip("Z")
+
+    # Truncate fractional seconds to 6 digits (Python's %f limit)
+    if "." in dt_str:
+        base, frac = dt_str.rsplit(".", 1)
+        dt_str = f"{base}.{frac[:6]}"
+
+    # Try parsing with and without fractional seconds
+    for fmt in ("%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"):
+        try:
+            dt = datetime.strptime(dt_str, fmt)
+            return utc_to_local(dt)
+        except ValueError:
+            continue
+
+    raise ValueError(f"Unable to parse datetime: {api_dt}")
+
+
+def utc_to_local(_dt):
+    return _dt.replace(tzinfo=timezone.utc).astimezone(tz=None)

todocli/utils/recurrence_util.py

@@ -0,0 +1,122 @@
+import re
+from datetime import date
+
+from todocli.models.todotask import RecurrencePatternType, DayOfWeek
+
+
+class InvalidRecurrenceExpression(Exception):
+    def __init__(self, expr):
+        self.message = f"Invalid recurrence expression: '{expr}'"
+        super().__init__(self.message)
+
+
+DAY_MAP = {
+    "mon": DayOfWeek.MONDAY,
+    "tue": DayOfWeek.TUESDAY,
+    "wed": DayOfWeek.WEDNESDAY,
+    "thu": DayOfWeek.THURSDAY,
+    "fri": DayOfWeek.FRIDAY,
+    "sat": DayOfWeek.SATURDAY,
+    "sun": DayOfWeek.SUNDAY,
+}
+
+UNIT_MAP = {
+    "day": RecurrencePatternType.DAILY,
+    "days": RecurrencePatternType.DAILY,
+    "week": RecurrencePatternType.WEEKLY,
+    "weeks": RecurrencePatternType.WEEKLY,
+    "month": RecurrencePatternType.ABSOLUTE_MONTHLY,
+    "months": RecurrencePatternType.ABSOLUTE_MONTHLY,
+    "year": RecurrencePatternType.ABSOLUTE_YEARLY,
+    "years": RecurrencePatternType.ABSOLUTE_YEARLY,
+}
+
+PRESET_MAP = {
+    "daily": (RecurrencePatternType.DAILY, 1),
+    "weekly": (RecurrencePatternType.WEEKLY, 1),
+    "monthly": (RecurrencePatternType.ABSOLUTE_MONTHLY, 1),
+    "yearly": (RecurrencePatternType.ABSOLUTE_YEARLY, 1),
+}
+
+WEEKDAYS = [
+    DayOfWeek.MONDAY,
+    DayOfWeek.TUESDAY,
+    DayOfWeek.WEDNESDAY,
+    DayOfWeek.THURSDAY,
+    DayOfWeek.FRIDAY,
+]
+
+
+def _parse_days(days_str):
+    days = []
+    for d in days_str.split(","):
+        d = d.strip().lower()
+        if d not in DAY_MAP:
+            raise ValueError(d)
+        days.append(DAY_MAP[d])
+    return days
+
+
+def parse_recurrence(expr):
+    if expr is None:
+        return None
+
+    expr = expr.strip()
+    if not expr:
+        return None
+
+    # Split on ":" to separate base from day specifiers
+    parts = expr.split(":", 1)
+    base_part = parts[0].strip().lower()
+    days_part = parts[1].strip() if len(parts) > 1 else None
+
+    pattern_type = None
+    interval = 1
+
+    # Check for "weekdays" preset
+    if base_part == "weekdays":
+        pattern_type = RecurrencePatternType.WEEKLY
+        interval = 1
+        days_part = days_part or "mon,tue,wed,thu,fri"
+
+    # Check for simple presets
+    elif base_part in PRESET_MAP:
+        pattern_type, interval = PRESET_MAP[base_part]
+
+    # Check for "every N unit" format
+    else:
+        match = re.match(r"^every\s+(\d+)\s+(days?|weeks?|months?|years?)$", base_part)
+        if match:
+            interval = int(match.group(1))
+            unit = match.group(2)
+            pattern_type = UNIT_MAP[unit]
+        else:
+            raise InvalidRecurrenceExpression(expr)
+
+    # Build pattern
+    today = date.today()
+    pattern = {
+        "type": pattern_type.value,
+        "interval": interval,
+    }
+
+    if days_part:
+        try:
+            pattern["daysOfWeek"] = [d.value for d in _parse_days(days_part)]
+        except ValueError:
+            raise InvalidRecurrenceExpression(expr)
+
+    if pattern_type == RecurrencePatternType.ABSOLUTE_MONTHLY:
+        pattern["dayOfMonth"] = today.day
+
+    if pattern_type == RecurrencePatternType.ABSOLUTE_YEARLY:
+        pattern["dayOfMonth"] = today.day
+        pattern["month"] = today.month
+
+    return {
+        "pattern": pattern,
+        "range": {
+            "type": "noEnd",
+            "startDate": today.isoformat(),
+        },
+    }

todocli/utils/update_checker.py

@@ -0,0 +1,55 @@
+import os
+import yaml
+import requests
+import todocli
+from datetime import datetime, timedelta
+
+DATE_FORMAT = "%Y%m%d"
+PYPI_PACKAGE = "microsoft-todo-cli"
+
+
+def check():
+    """Check for updates once per day, silently fail on errors."""
+    config_dir = "{}/.config/tod0".format(os.path.expanduser("~"))
+    if not os.path.isdir(config_dir):
+        os.makedirs(config_dir)
+
+    last_update_check = datetime(1990, 1, 1)
+    file_path = os.path.join(config_dir, "data.yml")
+    if os.path.isfile(file_path):
+        try:
+            with open(file_path, "r") as f:
+                data = yaml.load(f, yaml.SafeLoader)
+                if data and "last_update_check" in data:
+                    last_update_check = datetime.strptime(
+                        data["last_update_check"], DATE_FORMAT
+                    )
+        except (OSError, yaml.YAMLError, ValueError):
+            pass
+
+    # Check for updates if it has been a day since last check
+    if last_update_check + timedelta(days=1) < datetime.now():
+        try:
+            response = requests.get(
+                f"https://pypi.org/pypi/{PYPI_PACKAGE}/json",
+                timeout=5,
+            )
+            if response.ok:
+                data = response.json()
+                latest_version = data.get("info", {}).get("version", "0.0.0")
+                latest_tuple = tuple(map(int, latest_version.split(".")[:3]))
+                current_tuple = tuple(map(int, todocli.__version__.split(".")[:3]))
+
+                if latest_tuple > current_tuple:
+                    print(
+                        f"Update available: {todocli.__version__} -> {latest_version}. "
+                        f'Run "pip install --upgrade {PYPI_PACKAGE}"'
+                    )
+
+            with open(file_path, "w") as f:
+                yaml.dump(
+                    {"last_update_check": datetime.now().strftime(DATE_FORMAT)}, f
+                )
+        except (requests.RequestException, ValueError, KeyError, OSError):
+            # Silently ignore update check failures
+            pass