taskcheck 1.1.1__tar.gz → 1.2.0__tar.gz

{taskcheck-1.1.1/taskcheck.egg-info → taskcheck-1.2.0}/PKG-INFO

@@ -1,10 +1,13 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.1.1
+Version: 1.2.0
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: appdirs>=1.4.4
+Requires-Dist: google-api-python-client>=2.198.0
+Requires-Dist: google-auth>=2.56.2
+Requires-Dist: google-auth-oauthlib>=1.2.2
 Requires-Dist: icalendar>=6.0.1
 Requires-Dist: random-unicode-emoji>=2.8
 Requires-Dist: requests>=2.32.3

{taskcheck-1.1.1 → taskcheck-1.2.0}/pyproject.toml

@@ -1,11 +1,14 @@
 [project]
 name = "taskcheck"
-version = "1.1.1"
+version = "1.2.0"
 description = "Automatic scheduler for taskwarrior"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
   "appdirs>=1.4.4",
+  "google-api-python-client>=2.198.0",
+  "google-auth>=2.56.2",
+  "google-auth-oauthlib>=1.2.2",
   "icalendar>=6.0.1",
   "random-unicode-emoji>=2.8",
   "requests>=2.32.3",

{taskcheck-1.1.1 → taskcheck-1.2.0}/taskcheck/__main__.py

@@ -54,6 +54,11 @@ arg_parser.add_argument(
     default=True,
     help="Disable automatic reduction of urgency weight when tasks cannot be completed on time. (Enabled by default, meaning automatic reduction will occur.)",
 )
+arg_parser.add_argument(
+    "--add-google-calendar",
+    action="store_true",
+    help="Authenticate with Google, list calendars, and print a config section for the selected calendar.",
+)
 
 
 # Load working hours and exceptions from TOML file
@@ -100,6 +105,12 @@ def main():
         install()
         return
 
+    if getattr(args, "add_google_calendar", False) is True:
+        from taskcheck.google_calendar import add_google_calendar
+
+        add_google_calendar(taskrc=args.taskrc)
+        return
+
     if args.schedule:
         config = load_config()
         check_tasks_kwargs = dict(

{taskcheck-1.1.1 → taskcheck-1.2.0}/taskcheck/common.py

@@ -196,7 +196,7 @@ def mark_end_date(
             str(id),
             "modify",
             *start_end_fields,
-            f'scheduling:"{scheduling_note}"',
+            f"scheduling:{scheduling_note}",
         ],
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL,
@@ -211,16 +211,31 @@ def mark_end_date(
 def get_calendars(config, verbose=False, force_update=False):
     calendars = []
     for calname in config["calendars"]:
-        calendar = config["calendars"][calname]
-        calendar = ical_to_dict(
-            calendar["url"],
-            config["scheduler"]["days_ahead"],
-            all_day=calendar["event_all_day_is_blocking"],
-            expiration=calendar["expiration"],
-            verbose=verbose,
-            tz_name=calendar.get("timezone"),
-            force_update=force_update,
-        )
+        calendar_config = config["calendars"][calname]
+        if (
+            calendar_config.get("provider") == "google"
+            or calendar_config["url"].startswith("google://")
+        ):
+            from taskcheck.google_calendar import google_calendar_to_dict
+
+            calendar = google_calendar_to_dict(
+                calendar_config.get(
+                    "calendar_id", calendar_config["url"].removeprefix("google://")
+                ),
+                calendar_config["token_path"],
+                config["scheduler"]["days_ahead"],
+                all_day=calendar_config["event_all_day_is_blocking"],
+            )
+        else:
+            calendar = ical_to_dict(
+                calendar_config["url"],
+                config["scheduler"]["days_ahead"],
+                all_day=calendar_config["event_all_day_is_blocking"],
+                expiration=calendar_config["expiration"],
+                verbose=verbose,
+                tz_name=calendar_config.get("timezone"),
+                force_update=force_update,
+            )
         calendar.sort(key=lambda e: e["start"])
         calendars.append(calendar)
     if verbose:

taskcheck-1.2.0/taskcheck/google_calendar.py

@@ -0,0 +1,172 @@
+import json
+import warnings
+from datetime import datetime, time, timedelta
+from pathlib import Path
+from urllib.parse import urlparse
+
+import requests
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+
+from taskcheck.common import config_dir, get_task_env
+
+SCOPES = [
+    "openid",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile",
+    "https://www.googleapis.com/auth/calendar.readonly",
+]
+
+
+def get_google_data_dir(taskrc=None):
+    env = get_task_env(taskrc)
+    base = Path(env.get("TASKDATA", config_dir))
+    return base / "google"
+
+
+def get_client_secrets_path(taskrc=None):
+    repo_secret = Path.cwd() / "client_secret.json"
+    if repo_secret.exists():
+        return repo_secret
+    return get_google_data_dir(taskrc) / "client_secret.json"
+
+
+def get_token_path(account_id, taskrc=None):
+    return get_google_data_dir(taskrc) / f"{account_id}.token.json"
+
+
+def _safe_account_id(email):
+    return email.replace("@", "_").replace(".", "_")
+
+
+def load_credentials(taskrc=None):
+    secrets_path = get_client_secrets_path(taskrc)
+    if not secrets_path.exists():
+        raise FileNotFoundError(f"Missing Google OAuth client secrets: {secrets_path}")
+
+    token_dir = get_google_data_dir(taskrc)
+    token_dir.mkdir(parents=True, exist_ok=True)
+    token_path = token_dir / "current.token.json"
+    creds = None
+    if token_path.exists():
+        creds = Credentials.from_authorized_user_file(token_path, SCOPES)
+    if creds and creds.expired and creds.refresh_token:
+        creds.refresh(Request())
+    if not creds or not creds.valid:
+        flow = InstalledAppFlow.from_client_secrets_file(str(secrets_path), SCOPES)
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", message=r'^Scope has changed from .*')
+            creds = flow.run_local_server(port=0)
+        token_path.write_text(creds.to_json())
+    return creds
+
+
+def get_google_user_email(credentials):
+    response = requests.get(
+        "https://openidconnect.googleapis.com/v1/userinfo",
+        headers={"Authorization": f"Bearer {credentials.token}"},
+        timeout=30,
+    )
+    response.raise_for_status()
+    payload = response.json()
+    return payload["email"], payload.get("name", payload["email"])
+
+
+def list_calendars(credentials):
+    service = build("calendar", "v3", credentials=credentials, cache_discovery=False)
+    result = service.calendarList().list().execute()
+    return result.get("items", [])
+
+
+def google_calendar_to_dict(calendar_id, token_path, days_ahead, all_day=True):
+    token_path = Path(token_path).expanduser()
+    if not token_path.exists():
+        raise FileNotFoundError(f"Missing Google OAuth token: {token_path}")
+
+    credentials = Credentials.from_authorized_user_file(str(token_path), SCOPES)
+    if credentials.expired and credentials.refresh_token:
+        credentials.refresh(Request())
+        token_path.write_text(credentials.to_json())
+    if not credentials.valid:
+        raise RuntimeError(f"Invalid Google OAuth token: {token_path}")
+
+    service = build("calendar", "v3", credentials=credentials, cache_discovery=False)
+    timezone = datetime.now().astimezone().tzinfo
+    start = datetime.combine(datetime.now().date(), time.min, timezone)
+    end = start + timedelta(days=days_ahead + 1)
+    params = {
+        "calendarId": calendar_id,
+        "timeMin": start.isoformat(),
+        "timeMax": end.isoformat(),
+        "singleEvents": True,
+        "orderBy": "startTime",
+    }
+    events = []
+    while True:
+        result = service.events().list(**params).execute()
+        for item in result.get("items", []):
+            event_start = item.get("start", {})
+            event_end = item.get("end", {})
+            if "dateTime" in event_start and "dateTime" in event_end:
+                events.append(
+                    {"start": event_start["dateTime"], "end": event_end["dateTime"]}
+                )
+            elif all_day and "date" in event_start and "date" in event_end:
+                events.append(
+                    {
+                        "start": datetime.fromisoformat(event_start["date"]).isoformat(),
+                        "end": datetime.fromisoformat(event_end["date"]).isoformat(),
+                    }
+                )
+        page_token = result.get("nextPageToken")
+        if not page_token:
+            break
+        params["pageToken"] = page_token
+    return events
+
+
+def select_from_list(items, title_key="summary"):
+    for idx, item in enumerate(items, start=1):
+        print(f"{idx}. {item.get(title_key, item.get('id'))}")
+    while True:
+        choice = input("Select one calendar: ").strip()
+        if choice.isdigit() and 1 <= int(choice) <= len(items):
+            return items[int(choice) - 1]
+        print("Invalid selection")
+
+
+def render_calendar_config(account_id, calendar, taskrc=None):
+    token_path = get_token_path(account_id, taskrc)
+    return f'''[calendars."{account_id}.{calendar["id"]}"]
+url = "google://{calendar["id"]}"
+provider = "google"
+account = "{account_id}"
+calendar_id = "{calendar["id"]}"
+token_path = "{token_path}"
+event_all_day_is_blocking = true
+expiration = 0.25
+'''
+
+
+def add_google_calendar(taskrc=None):
+    credentials = load_credentials(taskrc)
+    email, name = get_google_user_email(credentials)
+    account_id = _safe_account_id(email)
+    token_path = get_token_path(account_id, taskrc)
+    token_path.parent.mkdir(parents=True, exist_ok=True)
+    token_path.write_text(credentials.to_json())
+
+    calendars = list_calendars(credentials)
+    if not calendars:
+        raise RuntimeError("No Google calendars found for this account")
+    calendar = select_from_list(calendars)
+    print(render_calendar_config(account_id, calendar, taskrc=taskrc))
+    return {
+        "account_id": account_id,
+        "email": email,
+        "name": name,
+        "calendar": calendar,
+        "token_path": str(token_path),
+    }

{taskcheck-1.1.1 → taskcheck-1.2.0}/taskcheck/parallel.py

@@ -535,7 +535,7 @@ def update_tasks_with_scheduling_info(task_info, verbose, taskrc):
                 "modify",
                 f"scheduled:{start_date}",
                 f"completion_date:{end_date}",
-                f'scheduling:"{scheduling_note.strip()}"',
+                f"scheduling:{scheduling_note.strip()}",
             ],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,

{taskcheck-1.1.1 → taskcheck-1.2.0}/taskcheck/report.py

@@ -187,7 +187,7 @@ def get_tasks(config, tasks, year, month, day):
             if m:
                 due = task.get("due", "")
                 if due:
-                    due = datetime.strptime(due, "%Y%m%dT%H%M%SZ")
+                    due = parse_taskwarrior_timestamp(due)
                     due = due - datetime.today()
                 valid_tasks.append(
                     {
@@ -219,7 +219,7 @@ def get_taskwarrior_date(date, _retry=True, taskrc=None):
     )
     date = date.stdout.strip()
     try:
-        date = datetime.strptime(date, "%Y-%m-%dT%H:%M:%S")
+        date = parse_taskwarrior_timestamp(date)
     except Exception as _:
         if _retry:
             return get_taskwarrior_date("today+" + date, False, taskrc)
@@ -247,7 +247,7 @@ def tostring(value):
         return value.strftime("%Y-%m-%d %H:%M")
     elif isinstance(value, str):
         try:
-            date = datetime.strptime(value, "%Y%m%dT%H%M%SZ")
+            date = parse_taskwarrior_timestamp(value)
             return date.strftime("%Y-%m-%d %H:%M")
         except ValueError:
             return value
@@ -275,7 +275,7 @@ def get_unplanned_tasks(config, tasks, taskrc=None):
         task
         for task in tasks
         if not task.get("due")
-        or datetime.strptime(task["due"], "%Y%m%dT%H%M%SZ") <= due_limit
+        or parse_taskwarrior_timestamp(task["due"]) <= due_limit
     ]
 
 
@@ -298,6 +298,15 @@ def generate_report(config, constraint, verbose=False, force_update=False, taskr
         display_tasks_table(console, config, this_day_tasks)
 
 
+def parse_taskwarrior_timestamp(value):
+    for fmt in ("%Y%m%dT%H%M%SZ", "%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%dT%H:%M:%S"):
+        try:
+            return datetime.strptime(value, fmt)
+        except ValueError:
+            pass
+    raise ValueError(value)
+
+
 def fetch_tasks(taskrc=None):
     """Fetch tasks from the task manager and return them as a JSON object."""
     from taskcheck.common import get_task_env

{taskcheck-1.1.1 → taskcheck-1.2.0/taskcheck.egg-info}/PKG-INFO

@@ -1,10 +1,13 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.1.1
+Version: 1.2.0
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: appdirs>=1.4.4
+Requires-Dist: google-api-python-client>=2.198.0
+Requires-Dist: google-auth>=2.56.2
+Requires-Dist: google-auth-oauthlib>=1.2.2
 Requires-Dist: icalendar>=6.0.1
 Requires-Dist: random-unicode-emoji>=2.8
 Requires-Dist: requests>=2.32.3

{taskcheck-1.1.1 → taskcheck-1.2.0}/taskcheck.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 taskcheck/__main__.py
 taskcheck/common.py
+taskcheck/google_calendar.py
 taskcheck/ical.py
 taskcheck/install.py
 taskcheck/parallel.py
@@ -14,6 +15,7 @@ taskcheck.egg-info/entry_points.txt
 taskcheck.egg-info/requires.txt
 taskcheck.egg-info/top_level.txt
 tests/test_common.py
+tests/test_google_calendar.py
 tests/test_ical.py
 tests/test_install.py
 tests/test_main.py

{taskcheck-1.1.1 → taskcheck-1.2.0}/taskcheck.egg-info/requires.txt

@@ -1,4 +1,7 @@
 appdirs>=1.4.4
+google-api-python-client>=2.198.0
+google-auth>=2.56.2
+google-auth-oauthlib>=1.2.2
 icalendar>=6.0.1
 random-unicode-emoji>=2.8
 requests>=2.32.3

{taskcheck-1.1.1 → taskcheck-1.2.0}/tests/test_common.py

@@ -13,7 +13,8 @@ from taskcheck.common import (
     get_long_range_time_map,
     get_tasks,
     get_calendars,
-    get_task_env
+    get_task_env,
+    mark_end_date,
 )
 
 
@@ -34,6 +35,23 @@ class TestTimeConversions:
         assert time_to_decimal(time(14, 15)) == 14.25
 
 
+class TestTaskUpdates:
+    @patch("taskcheck.common.subprocess.run")
+    def test_mark_end_date_passes_unquoted_scheduling_value(self, mock_run):
+        mark_end_date(
+            None,
+            "2026-07-29",
+            "2026-07-28",
+            "2026-07-28 - PT1H\n2026-07-29 - PT1H",
+            1,
+        )
+
+        command = mock_run.call_args.args[0]
+        assert command[-1] == (
+            "scheduling:2026-07-28 - PT1H\n2026-07-29 - PT1H"
+        )
+
+
 class TestDurationConversions:
     def test_pdth_to_hours(self):
         assert pdth_to_hours("P1H") == 1.0
@@ -132,6 +150,31 @@ class TestGetCalendars:
         assert calendars[0] == sample_calendar_events
         mock_ical.assert_called_once()
 
+    @patch("taskcheck.google_calendar.google_calendar_to_dict")
+    @patch("taskcheck.common.ical_to_dict")
+    def test_get_google_calendars(
+        self, mock_ical, mock_google, sample_config, sample_calendar_events
+    ):
+        sample_config["calendars"] = {
+            "google": {
+                "url": "google://primary",
+                "provider": "google",
+                "calendar_id": "primary",
+                "token_path": "/tmp/google.token.json",
+                "event_all_day_is_blocking": True,
+                "expiration": 0.25,
+            }
+        }
+        mock_google.return_value = sample_calendar_events
+
+        calendars = get_calendars(sample_config)
+
+        assert calendars == [sample_calendar_events]
+        mock_google.assert_called_once_with(
+            "primary", "/tmp/google.token.json", 7, all_day=True
+        )
+        mock_ical.assert_not_called()
+
 
 class TestEnvironmentVariables:
     def test_get_task_env_sets_both_variables(self, test_taskrc):

taskcheck-1.2.0/tests/test_google_calendar.py

@@ -0,0 +1,81 @@
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from taskcheck.google_calendar import (
+    _safe_account_id,
+    get_client_secrets_path,
+    google_calendar_to_dict,
+    render_calendar_config,
+)
+from taskcheck.__main__ import main
+
+
+def test_safe_account_id():
+    assert _safe_account_id("foo.bar@example.com") == "foo_bar_example_com"
+
+
+def test_get_client_secrets_path_prefers_repo_root(tmp_path, monkeypatch):
+    secret = tmp_path / "client_secret.json"
+    secret.write_text("{}")
+    monkeypatch.chdir(tmp_path)
+    assert get_client_secrets_path("/tmp/task") == secret
+
+
+@patch("taskcheck.google_calendar.get_token_path")
+def test_render_calendar_config(mock_token_path):
+    mock_token_path.return_value = "/tmp/task/google/foo.token.json"
+    cfg = render_calendar_config("foo", {"id": "abc123"}, taskrc="/tmp/task")
+    assert '[calendars."foo.abc123"]' in cfg
+    assert "calendar_id = \"abc123\"" in cfg
+
+
+@patch("taskcheck.google_calendar.build")
+@patch("taskcheck.google_calendar.Credentials.from_authorized_user_file")
+def test_google_calendar_to_dict(mock_credentials, mock_build, tmp_path):
+    token_path = tmp_path / "token.json"
+    token_path.write_text("{}")
+    mock_credentials.return_value = Mock(valid=True, expired=False)
+    events = Mock()
+    events.list.return_value.execute.return_value = {
+        "items": [
+            {
+                "start": {"dateTime": "2025-01-02T09:00:00+01:00"},
+                "end": {"dateTime": "2025-01-02T10:00:00+01:00"},
+            },
+            {
+                "start": {"date": "2025-01-03"},
+                "end": {"date": "2025-01-04"},
+            },
+        ]
+    }
+    mock_build.return_value.events.return_value = events
+
+    result = google_calendar_to_dict("primary", token_path, 7, all_day=True)
+
+    assert result == [
+        {
+            "start": "2025-01-02T09:00:00+01:00",
+            "end": "2025-01-02T10:00:00+01:00",
+        },
+        {"start": "2025-01-03T00:00:00", "end": "2025-01-04T00:00:00"},
+    ]
+    events.list.assert_called_once()
+
+
+@patch("taskcheck.google_calendar.add_google_calendar")
+@patch("taskcheck.__main__.arg_parser.parse_args")
+def test_main_add_google_calendar(mock_args, mock_add):
+    mock_args.return_value = Mock(
+        install=False,
+        add_google_calendar=True,
+        schedule=False,
+        report=None,
+        verbose=False,
+        force_update=False,
+        taskrc="/tmp/task",
+        urgency_weight=None,
+        dry_run=False,
+        auto_adjust_urgency=True,
+    )
+    main()
+    mock_add.assert_called_once_with(taskrc="/tmp/task")

{taskcheck-1.1.1 → taskcheck-1.2.0}/tests/test_parallel.py

@@ -538,4 +538,6 @@ class TestAutoAdjustUrgency:
             from taskcheck.parallel import update_tasks_with_scheduling_info
             update_tasks_with_scheduling_info(task_info, verbose=False, taskrc="/tmp/taskrc")
         mock_run.assert_called_once()
+        command = mock_run.call_args.args[0]
+        assert command[-1] == "scheduling:2023-12-05 - PT2H"
         assert mock_print.called

{taskcheck-1.1.1 → taskcheck-1.2.0}/tests/test_report.py

@@ -12,6 +12,7 @@ from taskcheck.report import (
     tostring,
     get_unplanned_tasks,
     fetch_tasks,
+    parse_taskwarrior_timestamp,
 )
 
 
@@ -152,10 +153,19 @@ class TestStringFormatting:
         dt = datetime(2023, 12, 5, 14, 30, 0)
         assert tostring(dt) == "2023-12-05 14:30"
         
-    def test_tostring_taskwarrior_date(self):
-        tw_date = "20231205T143000Z"
-        result = tostring(tw_date)
-        assert "2023-12-05 14:30" == result
+    @pytest.mark.parametrize(
+        ("timestamp", "expected"),
+        [
+            ("20231205T143000Z", datetime(2023, 12, 5, 14, 30)),
+            ("2023-12-05T14:30:00Z", datetime(2023, 12, 5, 14, 30)),
+        ],
+    )
+    def test_parse_taskwarrior_timestamp_supports_v2_and_v3(self, timestamp, expected):
+        assert parse_taskwarrior_timestamp(timestamp) == expected
+
+    @pytest.mark.parametrize("timestamp", ["20231205T143000Z", "2023-12-05T14:30:00Z"])
+    def test_tostring_taskwarrior_date(self, timestamp):
+        assert tostring(timestamp) == "2023-12-05 14:30"
         
     def test_tostring_regular_string(self):
         assert tostring("hello") == "hello"