Merge pull request #23 from mikez/main

add note for things.today; update tests; gitignore htmlcov

Author: AlexanderWillner

.gitignore

@@ -1,6 +1,7 @@
 .DS_Store
 dist
 build
+htmlcov
 __pycache__
 *.pyc
 *.egg-info

tests/test_things.py

@@ -4,97 +4,105 @@
 """Module documentation goes here."""
 
 import unittest
-from things import api
 
+import things
 
-DEMO_FILEPATH = "tests/main.sqlite"
+
+FILEPATH = dict(filepath="tests/main.sqlite")
 
 
 class ThingsCase(unittest.TestCase):
     """Class documentation goes here."""
 
     def test_inbox(self):
         """Test inbox."""
-        tasks = api.inbox(filepath=DEMO_FILEPATH)
+        tasks = things.inbox(**FILEPATH)
         self.assertEqual(1, len(tasks))
 
     def test_upcoming(self):
         """Test upcoming."""
-        tasks = api.upcoming(filepath=DEMO_FILEPATH)
+        tasks = things.upcoming(**FILEPATH)
         self.assertEqual(2, len(tasks))
 
     def test_due(self):
         """Test due."""
-        tasks = api.due(filepath=DEMO_FILEPATH)
+        tasks = things.due(**FILEPATH)
         self.assertEqual(1, len(tasks))
 
     def test_today(self):
         """Test today."""
-        tasks = api.today(filepath=DEMO_FILEPATH)
+        tasks = things.today(**FILEPATH)
         self.assertEqual(1, len(tasks))
 
     def test_anytime(self):
         """Test antime."""
-        tasks = api.anytime(filepath=DEMO_FILEPATH)
+        tasks = things.anytime(**FILEPATH)
         self.assertEqual(8, len(tasks))
 
     def test_logbook(self):
         """Test logbook."""
-        tasks = api.logbook(filepath=DEMO_FILEPATH)
+        tasks = things.logbook(**FILEPATH)
         self.assertEqual(21, len(tasks))
 
     def test_canceled(self):
         """Test canceled."""
-        tasks = api.canceled(filepath=DEMO_FILEPATH)
+        tasks = things.canceled(**FILEPATH)
         self.assertEqual(11, len(tasks))
 
     def test_completed(self):
         """Test completed."""
-        tasks = api.completed(filepath=DEMO_FILEPATH)
+        tasks = things.completed(**FILEPATH)
         self.assertEqual(10, len(tasks))
 
     def test_someday(self):
         """Test someday."""
-        tasks = api.someday(filepath=DEMO_FILEPATH)
+        tasks = things.someday(**FILEPATH)
         self.assertEqual(1, len(tasks))
 
     def test_get(self):
         """Test get."""
-        tasks = api.get('wrong_uuid', filepath=DEMO_FILEPATH)
+        tasks = things.get("wrong_uuid", **FILEPATH)
         self.assertEqual(None, tasks)
-        tasks = api.get('Qt2AY87x2QDdowSn9HKTt1', filepath=DEMO_FILEPATH)
+        tasks = things.get("wrong_uuid", "NOT FOUND", **FILEPATH)
+        self.assertEqual("NOT FOUND", tasks)
+        tasks = things.get("Qt2AY87x2QDdowSn9HKTt1", **FILEPATH)
         self.assertEqual(4, len(tasks))
 
     def test_todos(self):
         """Test all tasks."""
-        tasks = api.todos(start="Anytime", filepath=DEMO_FILEPATH)
+        tasks = things.todos(start="Anytime", **FILEPATH)
         self.assertEqual(5, len(tasks))
-        tasks = api.todos(start="Anytime", status="completed", filepath=DEMO_FILEPATH)
+        tasks = things.todos(start="Anytime", status="completed", **FILEPATH)
         self.assertEqual(6, len(tasks))
-        tasks = api.todos(status="completed", filepath=DEMO_FILEPATH)
+        tasks = things.todos(status="completed", **FILEPATH)
         self.assertEqual(10, len(tasks))
-        tasks = api.todos(include_items=True, filepath=DEMO_FILEPATH)
+        tasks = things.todos(include_items=True, **FILEPATH)
         self.assertEqual(9, len(tasks))
         with self.assertRaises(ValueError):
-            api.todos(status="wrong_value", filepath=DEMO_FILEPATH)
-        tasks = api.tasks('A2oPvtt4dXoypeoLc8uYzY', filepath=DEMO_FILEPATH)
+            things.todos(status="wrong_value", **FILEPATH)
+        tasks = things.tasks("A2oPvtt4dXoypeoLc8uYzY", **FILEPATH)
         self.assertEqual(13, len(tasks))
 
     def test_tags(self):
         """Test all tags."""
-        tags = api.tags(filepath=DEMO_FILEPATH)
+        tags = things.tags(**FILEPATH)
         self.assertEqual(5, len(tags))
 
     def test_projects(self):
         """Test all projects."""
-        projects = api.projects(filepath=DEMO_FILEPATH)
+        projects = things.projects(**FILEPATH)
         self.assertEqual(2, len(projects))
 
     def test_areas(self):
         """Test all test_areas."""
-        test_areas = api.areas(filepath=DEMO_FILEPATH)
+        test_areas = things.areas(**FILEPATH)
         self.assertEqual(1, len(test_areas))
 
+    def test_database_version(self):
+        """Test database version."""
+        version = things.Database(**FILEPATH).get_version()
+        self.assertEqual(18, version)
+
 
 if __name__ == "__main__":
     unittest.main()

things/api.py

@@ -6,6 +6,7 @@
 
 import os
 from shlex import quote
+import sys
 
 from .database import Database
 
@@ -362,7 +363,21 @@ def today(**kwargs):
     the Things app was in when you last opened it, that's the state
     reflected here by the API.
     """
-    return tasks(start_date=True, start="Anytime", index="todayIndex", **kwargs)
+    database = pop_database(kwargs)
+    if not database.was_modified_today():
+        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 to update the database.",
+            file=sys.stderr,
+        )
+    return tasks(
+        start_date=True,
+        start="Anytime",
+        index="todayIndex",
+        database=database,
+        **kwargs,
+    )
 
 
 def upcoming(**kwargs):

things/database.py

@@ -14,6 +14,7 @@
 __email__ = "[email protected]"
 __status__ = "Development"
 
+import datetime
 import os
 import sqlite3
 import sys
@@ -63,6 +64,7 @@ class Database:
     TABLE_TASKTAG = "TMTaskTag"
     TABLE_AREATAG = "TMAreaTag"
     TABLE_CHECKLIST_ITEM = "TMChecklistItem"
+    TABLE_META = "Meta"
     DATE_CREATE = "creationDate"
     DATE_MOD = "userModificationDate"
     DATE_DUE = "dueDate"
@@ -377,10 +379,20 @@ def get_tags_of_area(self, area_uuid):
                     AREA_TAG.areas = ?
                 ORDER BY AREA."index"
                 """
+
         return self.execute_query(
             query, parameters=(area_uuid,), row_factory=list_factory
         )
 
+    def get_version(self):
+        """Get Things Database version."""
+        import plistlib
+
+        query = f"SELECT value FROM {self.TABLE_META} WHERE key = 'databaseVersion'"
+        result = self.execute_query(query, row_factory=list_factory)
+        plist_bytes = result[0].encode()
+        return plistlib.loads(plist_bytes)
+
     def get_count(self, sql):
         sql = f"""SELECT COUNT(uuid) FROM ({sql})"""
         return self.execute_query(sql, row_factory=list_factory)[0]
@@ -406,6 +418,17 @@ def execute_query(self, sql, parameters=(), row_factory=None):
             print(f"Details: {error}.")
             sys.exit(2)
 
+    # -------- Utility methods --------
+
+    def last_modified(self):
+        mtime_seconds = os.path.getmtime(self.filepath)
+        return datetime.datetime.fromtimestamp(mtime_seconds)
+
+    def was_modified_today(self):
+        last_modified_date = self.last_modified().date()
+        todays_date = datetime.datetime.now().date()
+        return last_modified_date >= todays_date
+
     # -------- Historical methods (TK: transform) --------
 
     def get_trashed(self):