Merge pull request #80 from AlexanderWillner/main

Patch to show for #79: show "yellow" To-Dos in Today and remove them from Upcoming

Author: mikez

tests/main.sqlite

@@ -14,6 +14,31 @@
 
 THINGSDB = things.database.ENVIRONMENT_VARIABLE_WITH_FILEPATH  # type: ignore
 
+# AW: to be continued, helps updating the test expectations when modifying the DB
+HEADINGS = 3
+INBOX = 2
+TRASHED_TODOS = 2
+TRASHED_PROJECTS = 1
+TRASHED_CANCELLED = 1
+TRASHED_COMPLETED = 1
+TRASHED_PROJECT_TODOS = 1
+TRASHED_PROJECT_TRASHED_TODOS = 1
+TRASHED = (
+    TRASHED_TODOS
+    + TRASHED_PROJECTS
+    + TRASHED_CANCELLED
+    + TRASHED_COMPLETED
+    + TRASHED_PROJECT_TRASHED_TODOS
+)
+PROJECTS = 4
+UPCOMING = 1
+DEADLINE_PAST = 3
+DEADLINE_FUTURE = 1
+DEADLINE = DEADLINE_PAST + DEADLINE_FUTURE
+TODAY_PROJECTS = 1
+TODAY_TASKS = 4
+TODAY = TODAY_PROJECTS + TODAY_TASKS
+
 
 class ThingsCase(unittest.TestCase):  # noqa: V103 pylint: disable=R0904
     """Class documentation goes here."""
@@ -62,48 +87,68 @@ def test_search(self):
         #   "To-Do in Heading",
         #   "Completed To-Do in Heading",
         #   "Canceled To-Do in Heading"
-        self.assertEqual(3, len(todos))
+        self.assertEqual(HEADINGS, len(todos))
 
     def test_inbox(self):
         tasks = things.inbox()
-        self.assertEqual(2, len(tasks))
+        self.assertEqual(INBOX, len(tasks))
 
     def test_trashed(self):
-        tasks = things.trash()
-        self.assertEqual(5, len(tasks))
         todos = things.todos(trashed=True)
-        self.assertEqual(2, len(todos))
+        self.assertEqual(TRASHED_TODOS, len(todos))
         projects = things.projects(trashed=True)
-        self.assertEqual(1, len(projects))
+        self.assertEqual(TRASHED_PROJECTS, len(projects))
         projects = things.projects(trashed=None)
-        self.assertEqual(4, len(projects))
+        self.assertEqual(PROJECTS, len(projects))
         projects = things.trash(type="project")
-        self.assertEqual(1, len(projects))
+        self.assertEqual(TRASHED_PROJECTS, len(projects))
+        tasks = things.trash()
+        self.assertEqual(TRASHED, len(tasks))
 
         projects = things.trash(type="project", include_items=True)
         project_items = projects[0]["items"]
-        self.assertEqual(1, len(project_items))
+        self.assertEqual(TRASHED_PROJECTS, len(project_items))
         filtered_project_items = [
             item for item in project_items if "in Deleted Project" in item["title"]
         ]
-        self.assertEqual(1, len(filtered_project_items))
+        self.assertEqual(TRASHED_PROJECT_TODOS, len(filtered_project_items))
 
         # TK: Add this test case to the database:
         # to-do with trashed = 1 and whose project also has trashed = 1.
+        # AW: These are actually not shown in the GUI
         tasks = things.tasks(type="to-do", trashed=True, context_trashed=True)
         self.assertEqual(0, len(tasks))
 
     def test_upcoming(self):
         tasks = things.upcoming()
-        self.assertEqual(1, len(tasks))
+        self.assertEqual(UPCOMING, len(tasks))
 
     def test_deadlines(self):
+        tasks = things.tasks(deadline="past")
+        self.assertEqual(DEADLINE_PAST, len(tasks))
+        tasks = things.tasks(deadline="future")
+        self.assertEqual(DEADLINE_FUTURE, len(tasks))
         tasks = things.deadlines()
-        self.assertEqual(1, len(tasks))
+        self.assertEqual(DEADLINE, len(tasks))
+        with self.assertRaises(ValueError):
+            tasks = things.tasks(deadline="invalid_value")
 
     def test_today(self):
+        projects = things.today(type="project")
+        self.assertEqual(TODAY_PROJECTS, len(projects))
+        tasks = things.today(type="to-do")
+        self.assertEqual(TODAY_TASKS, len(tasks))
         tasks = things.today()
-        self.assertEqual(3, len(tasks))
+        self.assertEqual(TODAY, len(tasks))
+        tasks_today = [
+            "Upcoming To-Do in Today (yellow)",
+            "Project in Today",
+            "To-Do in Today",
+            "Repeating To-Do",
+            "Overdue Todo automatically shown in Today",
+        ]
+        for count, value in enumerate(tasks_today):
+            self.assertEqual(value, tasks[count]["title"])
 
     def test_checklist(self):
         checklist_items = things.checklist_items("3Eva4XFof6zWb9iSfYy4ej")
@@ -113,7 +158,7 @@ def test_checklist(self):
 
     def test_anytime(self):
         tasks = things.anytime()
-        self.assertEqual(12, len(tasks))
+        self.assertEqual(14, len(tasks))
         self.assertTrue(any(task.get("area_title") == "Area 1" for task in tasks))
 
     def test_logbook(self):
@@ -141,28 +186,28 @@ def test_get_by_uuid(self):
         self.assertEqual(4, len(task.keys()))  # type: ignore
 
     def test_todos(self):
-        todos = things.todos(start="Anytime")
-        self.assertEqual(8, len(todos))
         todos = things.todos(start="Anytime", status="completed")
         self.assertEqual(6, len(todos))
+        todos = things.todos(start="Anytime")
+        self.assertEqual(10, len(todos))
         todos = things.todos(status="completed")
         self.assertEqual(10, len(todos))
         todos = things.todos(include_items=True)
-        self.assertEqual(12, len(todos))
+        self.assertEqual(15, len(todos))
         tasks = things.tasks(include_items=True)
-        self.assertEqual(16, len(tasks))
+        self.assertEqual(19, len(tasks))
         with self.assertRaises(ValueError):
             things.todos(status="invalid_value")
         todo = things.todos("A2oPvtt4dXoypeoLc8uYzY")
         self.assertEqual(16, len(todo.keys()))  # type: ignore
 
     def test_tags(self):
+        tags = things.tasks(tag="Errand")
+        self.assertEqual(1, len(tags))
         tags = things.tags()
         self.assertEqual(5, len(tags))
         tags = things.tags(include_items=True)
         self.assertEqual(5, len(tags))
-        tags = things.tasks(tag="Errand")
-        self.assertEqual(1, len(tags))
         tag = things.tags(title="Errand")
         self.assertEqual("Errand", tag["title"])  # type: ignore
 
@@ -174,7 +219,7 @@ def test_projects(self):
         projects = things.projects()
         self.assertEqual(3, len(projects))
         projects = things.projects(include_items=True)
-        self.assertEqual(2, len(projects[0]["items"]))
+        self.assertEqual(4, len(projects[0]["items"]))
 
     def test_areas(self):
         areas = things.areas()
@@ -197,7 +242,7 @@ def test_last(self):
         self.assertEqual(len(last_tasks), 0)
 
         last_tasks = things.last("10000w")
-        self.assertEqual(len(last_tasks), 16)
+        self.assertEqual(len(last_tasks), 19)
 
         last_tasks = things.last("100y", status="completed")
         self.assertEqual(len(last_tasks), 10)

tests/main.sqlite-shm

@@ -9,7 +9,6 @@
 
 import os
 from shlex import quote
-import sys
 from typing import Dict, List, Union
 
 from things.database import Database
@@ -86,16 +85,27 @@ def tasks(uuid=None, include_items=False, **kwargs):  # noqa: C901
         - `tag == True`, only include tasks _with_ tags.
         - `tag == None` (default), then include all tasks.
 
-    start_date : bool or None, optional
+    start_date : bool, str or None, optional
         - `start_date == False`, only include tasks _without_ a start date.
         - `start_date == True`, only include tasks _with_ a start date.
+        - `start_date == 'future'`, only include tasks with a future start date.
+        - `start_date == 'past'`, only include tasks with a past start date.
         - `start_date == None` (default), then include all tasks.
 
-    deadline : bool or None, optional
+    deadline : bool, str or None, optional
         - `deadline == False`, only include tasks _without_ a deadline.
         - `deadline == True`, only include tasks _with_ a deadline.
+        - `deadline == 'future'`, only include tasks with a deadline in the future.
+        - `deadline == 'past'`, only include tasks with a deadline in the past.
         - `deadline == None` (default), then include all tasks.
 
+    deadline_suppressed : bool or None, optional
+        Handle overdue tasks that have been moved from Today to Inbox, Anytime, or Someday.
+        - `deadline_suppressed == True`, only include tasks with an overdue deadline
+          that have been moved from the today view (Inbox, Anytime, Someday).
+        - `deadline_suppressed == False`, skip tasks with an overdue deadline
+          that have been moved from the today view to another view (Inbox, Anytime, Someday).
+
     trashed : bool or None, optional, default False
         - `trashed == False` (default), only include non-trashed tasks.
         - `trashed == True`, only include trashed tasks.
@@ -476,30 +486,45 @@ def today(**kwargs):
     """
     Read Today's tasks into dicts.
 
-    Note: This might not produce desired results if the Things app hasn't
-    been opened yet today and the yellow "OK" button clicked for new tasks.
-    In general, you can assume that whatever state the Things app was in
-    when you last opened it, that's the state reflected here by the API.
+    Note: This method is a bit tricky.
+    The Things database reflects the status of the Things app when it was last opened.
+    When you open the Things app, new to-dos might have appeared in the Today view.
+    Those to-dos are indicated by a yellow dot in the app.
+    We try to predict what those new to-dos would be and return them as well.
+    Some cases, however, are not yet covered. This includes repeating to-dos.
 
     See `things.api.tasks` for details on the optional parameters.
     """
-    database = pop_database(kwargs)
-    if not database.was_modified_today():  # pragma: no cover
-        print(
-            "[NOTE] The results reflect the state of the Things app "
-            "when it was last run. If the results seem out of date, "
-            "then run the Things app and click the yellow 'OK' button "
-            "to update Today's to-dos and projects.",
-            file=sys.stderr,
-        )
-    return tasks(
+    regular_today_tasks = tasks(
         start_date=True,
         start="Anytime",
         index="todayIndex",
-        database=database,
         **kwargs,
     )
 
+    unconfirmed_scheduled_tasks = tasks(
+        start_date="past",
+        start="Someday",
+        index="todayIndex",
+        **kwargs,
+    )
+
+    unconfirmed_overdue_tasks = tasks(
+        start_date=False,
+        deadline="past",
+        deadline_suppressed=False,
+        **kwargs,
+    )
+
+    result = [
+        *regular_today_tasks,
+        *unconfirmed_scheduled_tasks,
+        *unconfirmed_overdue_tasks,
+    ]
+    result.sort(key=lambda task: (task["today_index"], task["start_date"]))
+
+    return result
+
 
 def upcoming(**kwargs):
     """
@@ -510,7 +535,7 @@ def upcoming(**kwargs):
 
     For details on parameters, see `things.api.tasks`.
     """
-    return tasks(start_date=True, start="Someday", **kwargs)
+    return tasks(start_date="future", start="Someday", **kwargs)
 
 
 def anytime(**kwargs):