things-py 0.0.2__tar.gz → 0.0.3__tar.gz

{things.py-0.0.2 → things.py-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: things.py
-Version: 0.0.2
+Version: 0.0.3
 Summary: A simple Python 3 library to read your Things app data.
 Home-page: https://github.com/thingsapi/things.py
 Author: Alexander Willner, Michael B.
@@ -14,7 +14,7 @@ Description: # Things Python API
         [![Coverage Status](https://codecov.io/gh/thingsapi/things.py/branch/main/graph/badge.svg?token=DBWGKAEYAP)](https://codecov.io/gh/thingsapi/things.py)
         [![GitHub Release](https://img.shields.io/github/v/release/thingsapi/things.py?sort=semver)](https://github.com/thingsapi/things.py/releases)
         [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-        [![PyPI - Downloads](https://img.shields.io/pypi/dm/things?label=pypi%20downloads)](https://pypi.org/project/things/)
+        [![PyPI - Downloads](https://img.shields.io/pypi/dm/things.py?label=pypi%20downloads)](https://pypi.org/project/things.py/)
         [![GitHub Download Count](https://img.shields.io/github/downloads/thingsapi/things.py/total.svg)](https://github.com/thingsapi/things.py/releases)
         [![GitHub Issues](https://img.shields.io/github/issues/thingsapi/things.py)](https://github.com/thingsapi/things.py/issues)
         [![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/quality/g/thingsapi/things.py)](https://scrutinizer-ci.com/g/thingsapi/things.py/?branch=master)

{things.py-0.0.2 → things.py-0.0.3}/README.md

@@ -6,7 +6,7 @@ A simple Python 3 library to read your [Things app](https://culturedcode.com/thi
 [![Coverage Status](https://codecov.io/gh/thingsapi/things.py/branch/main/graph/badge.svg?token=DBWGKAEYAP)](https://codecov.io/gh/thingsapi/things.py)
 [![GitHub Release](https://img.shields.io/github/v/release/thingsapi/things.py?sort=semver)](https://github.com/thingsapi/things.py/releases)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/things?label=pypi%20downloads)](https://pypi.org/project/things/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/things.py?label=pypi%20downloads)](https://pypi.org/project/things.py/)
 [![GitHub Download Count](https://img.shields.io/github/downloads/thingsapi/things.py/total.svg)](https://github.com/thingsapi/things.py/releases)
 [![GitHub Issues](https://img.shields.io/github/issues/thingsapi/things.py)](https://github.com/thingsapi/things.py/issues)
 [![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/quality/g/thingsapi/things.py)](https://scrutinizer-ci.com/g/thingsapi/things.py/?branch=master)

{things.py-0.0.2 → things.py-0.0.3}/setup.py

@@ -14,16 +14,16 @@ def package_files(directory):
     return paths
 
 
-APP = ['']
+APP = [""]
 APP_NAME = "Things"
 AUTHOR = "Alexander Willner, Michael B."
 AUTHOR_MAIL = "alex@willner.ws"
 DESCRIPTON = "A simple Python 3 library to read your Things app data."
 URL = "https://github.com/thingsapi/things.py"
-VERSION = "0.0.2"
-DATA_FILES = package_files('')
+VERSION = "0.0.3"
+DATA_FILES = package_files("")
 OPTIONS = {
-    'argv_emulation': False,
+    "argv_emulation": False,
 }
 
 with open("README.md", "r") as fh:
@@ -44,11 +44,11 @@ setup(
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: Apache Software License",
         "Operating System :: MacOS :: MacOS X",
-        "Natural Language :: English"
+        "Natural Language :: English",
     ],
-    python_requires='>=3.6',
+    python_requires=">=3.6",
     version=VERSION,
     data_files=DATA_FILES,
-    options={'py2app': OPTIONS},
-    setup_requires=['py2app'],
+    options={"py2app": OPTIONS},
+    setup_requires=["py2app"],
 )

{things.py-0.0.2 → things.py-0.0.3}/tests/test_things.py

@@ -16,9 +16,9 @@ class ThingsCase(unittest.TestCase):
 
     def test_search(self):
         """Test search."""
-        tasks = things.search('wrong_query', **FILEPATH)
+        tasks = things.search("wrong_query", **FILEPATH)
         self.assertEqual(0, len(tasks))
-        tasks = things.search('To-Do % Heading', **FILEPATH)
+        tasks = things.search("To-Do % Heading", **FILEPATH)
         self.assertEqual(1, len(tasks))
 
     def test_inbox(self):
@@ -31,9 +31,9 @@ class ThingsCase(unittest.TestCase):
         tasks = things.upcoming(**FILEPATH)
         self.assertEqual(2, len(tasks))
 
-    def test_due(self):
-        """Test due."""
-        tasks = things.due(**FILEPATH)
+    def test_deadlines(self):
+        """Test deadlines."""
+        tasks = things.deadlines(**FILEPATH)
         self.assertEqual(1, len(tasks))
 
     def test_today(self):

{things.py-0.0.2 → things.py-0.0.3}/things/__init__.py

@@ -5,7 +5,7 @@ from things.api import (  # noqa
     areas,
     canceled,
     completed,
-    due,
+    deadlines,
     get,
     inbox,
     link,

{things.py-0.0.2 → things.py-0.0.3}/things/api.py

@@ -85,11 +85,24 @@ def tasks(uuid=None, include_items=False, **kwargs):  # noqa: C901
         If the argument is `True`, only include tasks _with_ a start date.
         If the argument is `None` (default), then include all tasks.
 
-    due_date : bool or None, optional
-        If the argument is `False`, only include tasks _without_ a due date.
-        If the argument is `True`, only include tasks _with_ a due date.
+    deadline : bool or None, optional
+        If the argument is `False`, only include tasks _without_ a deadline.
+        If the argument is `True`, only include tasks _with_ a deadline.
         If the argument is `None` (default), then include all tasks.
 
+    search_query : str, optional
+        The string value is passed to the SQL LIKE operator. It can thus
+        include placeholders such as '%' and '_'. Per default, it is
+        wrapped in '% ... %'.
+
+        Currently titles and notes of to-dos, projects, headings, and areas
+        are taken into account.
+
+        If the query is `False`, then return items where titles or notes
+        are empty.
+
+        If the query `None`, then return all items.
+
     index : {'index', 'todayIndex'}, default 'index'
         Database field to order result by.
 
@@ -315,26 +328,35 @@ def tags(title=None, include_items=False, **kwargs):
 # Utility API functions derived from above
 # --------------------------------------------------
 
+
 def search(query: str, **kwargs) -> List[Dict]:
     """
-    Search the database. This takes mainly notes and titles into account.
+    Search tasks in the database.
 
-    Parameters
-    ----------
-    query : str
-        The string with optional placeholders (%) to search for.
+    Currently any part of a title and note of a to-do, project,
+    heading, or area is matched.
 
-    Returns
-    -------
-    list of dict
-        Representing Things items.
+    See the `search_query` parameter of `api.tasks` for details.
 
     Examples
     --------
-    >>> things.search('substring % within notes and titles')
-    ...
+    >>> things.search('book')
+    [{'uuid': 'YrOmUnEXASmpq8ch6RsyPt',
+      'type': 'to-do',
+      'title': 'Book a hotel room',
+      ...},
+      {'uuid': 'KVHAxIIJ52a0h1RCbmg5D6',
+      'type': 'to-do',
+      'title': 'Book flights',
+      ...}]
+
+    >>> things.search('book%room')
+    [{'uuid': 'YrOmUnEXASmpq8ch6RsyPt',
+      'type': 'to-do',
+      'title': 'Book a hotel room',
+      ...}]
     """
-    return tasks(querystr=query, **kwargs)
+    return tasks(search_query=query, **kwargs)
 
 
 def get(uuid, default=None, **kwargs):
@@ -405,8 +427,8 @@ def today(**kwargs):
 
 def upcoming(**kwargs):
     """
-    Note: unscheduled tasks with a due date are not included here.
-    See the `due` function instead.
+    Note: unscheduled tasks with a deadline are not included here.
+    See the `deadline` function instead.
     """
     return tasks(start_date=True, start="Someday", **kwargs)
 
@@ -444,9 +466,9 @@ def completed(**kwargs):
     return tasks(status="completed", **kwargs)
 
 
-def due(**kwargs):
-    result = tasks(due_date=True, **kwargs)
-    result.sort(key=lambda task: task["due_date"])
+def deadlines(**kwargs):
+    result = tasks(deadline=True, **kwargs)
+    result.sort(key=lambda task: task["deadline"])
     return result
 
 

{things.py-0.0.2 → things.py-0.0.3}/things/database.py

@@ -1,7 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-"""Simple read-only API for Things."""
+"""Simple read-only API for Things.
+
+We attempt to follow the names used in the Things app, URL Scheme,
+and SQL database whenever possible.
+"""
 
 from __future__ import print_function
 
@@ -25,19 +29,19 @@ DEFAULT_DATABASE_FILEPATH = os.path.expanduser(
     "/Things Database.thingsdatabase/main.sqlite"
 )
 
-START_TO_QUERY = {
+START_TO_FILTER = {
     "Inbox": "start = 0",
     "Anytime": "start = 1",
     "Someday": "start = 2",
 }
 
-STATUS_TO_QUERY = {
+STATUS_TO_FILTER = {
     "incomplete": "status = 0",
     "canceled": "status = 2",
     "completed": "status = 3",
 }
 
-TYPE_TO_QUERY = {"to-do": "type = 0", "project": "type = 1", "heading": "type = 2"}
+TYPE_TO_FILTER = {"to-do": "type = 0", "project": "type = 1", "heading": "type = 2"}
 
 INDICES = ("index", "todayIndex")
 
@@ -67,25 +71,25 @@ class Database:
     TABLE_META = "Meta"
     DATE_CREATE = "creationDate"
     DATE_MOD = "userModificationDate"
-    DATE_DUE = "dueDate"
+    DATE_DEADLINE = "dueDate"
     DATE_START = "startDate"
     DATE_STOP = "stopDate"
-    IS_INBOX = START_TO_QUERY["Inbox"]
-    IS_ANYTIME = START_TO_QUERY["Anytime"]
-    IS_SOMEDAY = START_TO_QUERY["Someday"]
+    IS_INBOX = START_TO_FILTER["Inbox"]
+    IS_ANYTIME = START_TO_FILTER["Anytime"]
+    IS_SOMEDAY = START_TO_FILTER["Someday"]
     IS_SCHEDULED = f"{DATE_START} IS NOT NULL"
     IS_NOT_SCHEDULED = f"{DATE_START} IS NULL"
-    IS_DUE = f"{DATE_DUE} IS NOT NULL"
+    IS_DEADLINE = f"{DATE_DEADLINE} IS NOT NULL"
     IS_RECURRING = "recurrenceRule IS NOT NULL"
     IS_NOT_RECURRING = "recurrenceRule IS NULL"
-    IS_TODO = TYPE_TO_QUERY["to-do"]
-    IS_PROJECT = TYPE_TO_QUERY["project"]
-    IS_HEADING = TYPE_TO_QUERY["heading"]
+    IS_TODO = TYPE_TO_FILTER["to-do"]
+    IS_PROJECT = TYPE_TO_FILTER["project"]
+    IS_HEADING = TYPE_TO_FILTER["heading"]
     IS_NOT_TRASHED = "trashed = 0"
     IS_TRASHED = "trashed = 1"
-    IS_INCOMPLETE = STATUS_TO_QUERY["incomplete"]
-    IS_CANCELED = STATUS_TO_QUERY["canceled"]
-    IS_COMPLETED = STATUS_TO_QUERY["completed"]
+    IS_INCOMPLETE = STATUS_TO_FILTER["incomplete"]
+    IS_CANCELED = STATUS_TO_FILTER["canceled"]
+    IS_COMPLETED = STATUS_TO_FILTER["completed"]
     RECURRING_IS_NOT_PAUSED = "instanceCreationPaused = 0"
     RECURRING_HAS_NEXT_STARTDATE = "nextInstanceStartDate IS NOT NULL"
 
@@ -120,10 +124,10 @@ class Database:
         heading=None,
         tag=None,
         start_date=None,
-        due_date=None,
+        deadline=None,
         index="index",
         count_only=False,
-        querystr=None
+        search_query=None,
     ):
         """Get tasks. See `api.tasks` for details on parameters."""
 
@@ -131,9 +135,9 @@ class Database:
         start = start and start.title()
 
         # Validation
-        validate("type", type, [None] + list(TYPE_TO_QUERY))
-        validate("status", status, [None] + list(STATUS_TO_QUERY))
-        validate("start", start, [None] + list(START_TO_QUERY))
+        validate("type", type, [None] + list(TYPE_TO_FILTER))
+        validate("status", status, [None] + list(STATUS_TO_FILTER))
+        validate("start", start, [None] + list(START_TO_FILTER))
         validate("index", index, list(INDICES))
 
         if tag is not None:
@@ -149,39 +153,39 @@ class Database:
         # See: https://docs.python.org/3/library/sqlite3.html#sqlite3.Cursor.execute
 
         if uuid:
-            query = f"TRUE {make_filter('TASK.uuid', uuid)}"
+            where_predicate = f"TRUE {make_filter('TASK.uuid', uuid)}"
         else:
-            start_query = START_TO_QUERY.get(start)
-            status_query = STATUS_TO_QUERY.get(status)
-            type_query = TYPE_TO_QUERY.get(type)
+            start_filter = START_TO_FILTER.get(start, "")
+            status_filter = STATUS_TO_FILTER.get(status, "")
+            type_filter = TYPE_TO_FILTER.get(type, "")
 
-            query = f"""
+            where_predicate = f"""
                     TASK.{self.IS_NOT_TRASHED}
-                    {f"AND TASK.{type_query}" if type_query else ""}
-                    {f"AND TASK.{start_query}" if start_query else ""}
-                    {f"AND TASK.{status_query}" if status_query else ""}
+                    {type_filter and f"AND TASK.{type_filter}"}
+                    {start_filter and f"AND TASK.{start_filter}"}
+                    {status_filter and f"AND TASK.{status_filter}"}
                     AND TASK.{self.IS_NOT_RECURRING}
                     AND (PROJECT.title IS NULL OR PROJECT.{self.IS_NOT_TRASHED})
                     AND (HEADPROJ.title IS NULL OR HEADPROJ.{self.IS_NOT_TRASHED})
-                    {make_search(querystr)}
                     {make_filter('TASK.uuid', uuid)}
                     {make_filter("TASK.area", area)}
                     {make_filter("TASK.project", project)}
                     {make_filter("TASK.actionGroup", heading)}
                     {make_filter("TASK.startDate", start_date)}
-                    {make_filter("TASK.dueDate", due_date)}
+                    {make_filter(f"TASK.{self.DATE_DEADLINE}", deadline)}
                     {make_filter("TAG.title", tag)}
+                    {make_search_filter(search_query)}
                     ORDER BY TASK."{index}"
                     """
 
-        sql = self.make_tasks_sql(query)
+        sql_query = self.make_task_sql_query(where_predicate)
         if count_only:
-            return self.get_count(sql)
+            return self.get_count(sql_query)
         else:
-            return self.execute_query(sql)
+            return self.execute_query(sql_query)
 
-    def make_tasks_sql(self, query):
-        """Make SQL for tasks"""
+    def make_task_sql_query(self, where_predicate):
+        """Make SQL query for Task table"""
         return f"""
             SELECT DISTINCT
                 TASK.uuid,
@@ -221,8 +225,8 @@ class Database:
                     WHEN CHECKLIST_ITEM.uuid IS NOT NULL THEN 1
                 END AS checklist,
                 date(TASK.startDate, "unixepoch") AS start_date,
-                date(TASK.dueDate, "unixepoch") AS due_date,
-                date(TASK.stopDate, "unixepoch") AS stop_date,
+                date(TASK.{self.DATE_DEADLINE}, "unixepoch") AS deadline,
+                date(TASK.stopDate, "unixepoch") AS "stop_date",
                 datetime(TASK.{self.DATE_CREATE}, "unixepoch", "localtime") AS created,
                 datetime(TASK.{self.DATE_MOD}, "unixepoch", "localtime") AS modified
             FROM
@@ -244,11 +248,11 @@ class Database:
                 ON CHECKLIST_ITEM.task = TASK.uuid
             WHERE
                 {self.filter}
-                {query}
+                {where_predicate}
             """
 
-    def get_rows(self, query):
-        return self.execute_query(self.make_tasks_sql(query))
+    def get_task_rows(self, where_predicate):
+        return self.execute_query(self.make_task_sql_query(where_predicate))
 
     def get_areas(self, uuid=None, tag=None, count_only=False):
         """Get areas. See `api.areas` for details on parameters."""
@@ -266,7 +270,7 @@ class Database:
             raise ValueError(f"No such area uuid found: {uuid!r}")
 
         # Query
-        query = f"""
+        sql_query = f"""
                 SELECT
                     AREA.uuid,
                     'area' as type,
@@ -287,13 +291,13 @@ class Database:
                 ORDER BY AREA."index"
                 """
         if count_only:
-            return self.get_count(query)
+            return self.get_count(sql_query)
         else:
-            return self.execute_query(query)
+            return self.execute_query(sql_query)
 
     def get_checklist_items(self, task_uuid=None):
         """Get checklist items."""
-        query = f"""
+        sql_query = f"""
                 SELECT
                     CHECKLIST_ITEM.title,
                     CASE
@@ -302,7 +306,7 @@ class Database:
                         WHEN CHECKLIST_ITEM.{self.IS_CANCELED} THEN 'canceled'
                     END AS status,
                     date(CHECKLIST_ITEM.stopDate, "unixepoch") AS stop_date,
-                    'checklist item' as type,
+                    'checklist-item' as type,
                     CHECKLIST_ITEM.uuid,
                     datetime(
                         CHECKLIST_ITEM.{self.DATE_MOD}, "unixepoch", "localtime"
@@ -316,7 +320,7 @@ class Database:
                     CHECKLIST_ITEM.task = ?
                 ORDER BY CHECKLIST_ITEM."index"
                 """
-        return self.execute_query(query, (task_uuid,))
+        return self.execute_query(sql_query, (task_uuid,))
 
     def get_tags(self, title=None, area=None, task=None, titles_only=False):
         """Get tags. See `api.tags` for details on parameters."""
@@ -333,84 +337,83 @@ class Database:
             return self.get_tags_of_area(area)
 
         if titles_only:
-            query = f'SELECT title FROM {self.TABLE_TAG} ORDER BY "index"'
-            return self.execute_query(query, row_factory=list_factory)
+            sql_query = f'SELECT title FROM {self.TABLE_TAG} ORDER BY "index"'
+            return self.execute_query(sql_query, row_factory=list_factory)
         else:
-            query = f"""
-                    SELECT
-                        uuid,
-                        'tag' AS type,
-                        title,
-                        shortcut
-                    FROM
-                        {self.TABLE_TAG}
-                    WHERE
-                        TRUE
-                        {make_filter('title', title)}
-                    ORDER BY "index"
-                    """
-            return self.execute_query(query)
-
-    def get_tags_of_task(self, task_uuid):
-        """Get tag titles of task"""
-        query = f"""
+            sql_query = f"""
                 SELECT
-                    TAG.title
+                    uuid,
+                    'tag' AS type,
+                    title,
+                    shortcut
                 FROM
-                    {self.TABLE_TASKTAG} AS TASK_TAG
-                LEFT OUTER JOIN
-                    {self.TABLE_TAG} TAG ON TAG.uuid = TASK_TAG.tags
+                    {self.TABLE_TAG}
                 WHERE
-                    TASK_TAG.tasks = ?
-                ORDER BY TAG."index"
+                    TRUE
+                    {make_filter('title', title)}
+                ORDER BY "index"
                 """
+            return self.execute_query(sql_query)
+
+    def get_tags_of_task(self, task_uuid):
+        """Get tag titles of task"""
+        sql_query = f"""
+            SELECT
+                TAG.title
+            FROM
+                {self.TABLE_TASKTAG} AS TASK_TAG
+            LEFT OUTER JOIN
+                {self.TABLE_TAG} TAG ON TAG.uuid = TASK_TAG.tags
+            WHERE
+                TASK_TAG.tasks = ?
+            ORDER BY TAG."index"
+            """
         return self.execute_query(
-            query, parameters=(task_uuid,), row_factory=list_factory
+            sql_query, parameters=(task_uuid,), row_factory=list_factory
         )
 
     def get_tags_of_area(self, area_uuid):
         """Get tag titles for area"""
-        query = f"""
-                SELECT
-                    AREA.title
-                FROM
-                    {self.TABLE_AREATAG} AS AREA_TAG
-                LEFT OUTER JOIN
-                    {self.TABLE_TAG} AREA ON AREA.uuid = AREA_TAG.tags
-                WHERE
-                    AREA_TAG.areas = ?
-                ORDER BY AREA."index"
-                """
-
+        sql_query = f"""
+            SELECT
+                AREA.title
+            FROM
+                {self.TABLE_AREATAG} AS AREA_TAG
+            LEFT OUTER JOIN
+                {self.TABLE_TAG} AREA ON AREA.uuid = AREA_TAG.tags
+            WHERE
+                AREA_TAG.areas = ?
+            ORDER BY AREA."index"
+            """
         return self.execute_query(
-            query, parameters=(area_uuid,), row_factory=list_factory
+            sql_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)
+        sql_query = f"SELECT value FROM {self.TABLE_META} WHERE key = 'databaseVersion'"
+        result = self.execute_query(sql_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]
+        sql_query = f"""SELECT COUNT(uuid) FROM ({sql})"""
+        return self.execute_query(sql_query, row_factory=list_factory)[0]
 
     # noqa todo: add type hinting for resutl (List[Tuple[str, Any]]?)
-    def execute_query(self, sql, parameters=(), row_factory=None):
-        """Run the actual query"""
+    def execute_query(self, sql_query, parameters=(), row_factory=None):
+        """Run the actual SQL query"""
         if self.debug is True:
             print(self.filepath)
-            print(sql)
+            print(sql_query)
         try:
             uri = f"file:{self.filepath}?mode=ro"  # "ro" means read-only
             connection = sqlite3.connect(uri, uri=True)
             connection.row_factory = row_factory or dict_factory
             cursor = connection.cursor()
-            cursor.execute(sql, parameters)
+            cursor.execute(sql_query, parameters)
             tasks = cursor.fetchall()
             if self.debug:
                 for task in tasks:
@@ -441,7 +444,7 @@ class Database:
                 TASK.{self.IS_TODO}
                 ORDER BY TASK.{self.DATE_STOP}
                 """
-        return self.get_rows(query)
+        return self.get_task_rows(query)
 
     def get_lint(self):
         """Get tasks that float around"""
@@ -454,7 +457,7 @@ class Database:
             TASK.area IS NULL AND
             TASK.actionGroup IS NULL
             """
-        return self.get_rows(query)
+        return self.get_task_rows(query)
 
     def get_empty_projects(self):
         """Get projects that are empty"""
@@ -480,7 +483,7 @@ class Database:
                    )
                 ) = 0
             """
-        return self.get_rows(query)
+        return self.get_task_rows(query)
 
     def get_largest_projects(self):
         """Get projects that are empty"""
@@ -667,33 +670,40 @@ def make_filter(column, value):
     }.get(value, default)
 
 
-def make_search(value: str) -> str:
-    query = ""
+def make_search_filter(query: str) -> str:
+    """
+    Example
+    -------
+    >>> make_search_filter('dinner')
+    'AND (
+        TASK.title LIKE "%dinner%"
+        OR TASK.notes LIKE "%dinner%"
+        OR AREA.title LIKE "%dinner%"
+    )'
+    """
+    if not query:
+        return ""
+
     # noqa todo 'TMChecklistItem.title'
-    sources = ['TASK.title', 'TASK.notes', 'AREA.title']
-    for source in sources:
-        subsearch = make_sub_search(source, value)
-        if subsearch:
-            query = query + subsearch + ' OR '
-    if query.endswith(' OR '):
-        query = query[:-4]
-    if query != "":
-        query = 'AND (' + query + ')'
-    return query
-
-
-def make_sub_search(column, value):
-    default = f'{column} LIKE "%{value}%"'
-    return {
-        None: "",
-        False: f"{column} IS NULL",
-        True: f"{column} IS NOT NULL",
-    }.get(value, default)
+    columns = ["TASK.title", "TASK.notes", "AREA.title"]
+
+    sub_searches = (f'{column} LIKE "%{query}%"' for column in columns)
+
+    return f"AND ({' OR '.join(sub_searches)})"
 
 
 def validate(parameter, argument, valid_arguments):
     """
     For a given parameter, check if its argument type is valid.
+    If not, then raise ValueError.
+
+    Example
+    -------
+    >>> validate(
+        parameter='status',
+        argument='completed',
+        valid_arguments=['incomplete', 'completed']
+    )
     """
     if argument in valid_arguments:
         return

{things.py-0.0.2 → things.py-0.0.3}/things.py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: things.py
-Version: 0.0.2
+Version: 0.0.3
 Summary: A simple Python 3 library to read your Things app data.
 Home-page: https://github.com/thingsapi/things.py
 Author: Alexander Willner, Michael B.
@@ -14,7 +14,7 @@ Description: # Things Python API
         [![Coverage Status](https://codecov.io/gh/thingsapi/things.py/branch/main/graph/badge.svg?token=DBWGKAEYAP)](https://codecov.io/gh/thingsapi/things.py)
         [![GitHub Release](https://img.shields.io/github/v/release/thingsapi/things.py?sort=semver)](https://github.com/thingsapi/things.py/releases)
         [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-        [![PyPI - Downloads](https://img.shields.io/pypi/dm/things?label=pypi%20downloads)](https://pypi.org/project/things/)
+        [![PyPI - Downloads](https://img.shields.io/pypi/dm/things.py?label=pypi%20downloads)](https://pypi.org/project/things.py/)
         [![GitHub Download Count](https://img.shields.io/github/downloads/thingsapi/things.py/total.svg)](https://github.com/thingsapi/things.py/releases)
         [![GitHub Issues](https://img.shields.io/github/issues/thingsapi/things.py)](https://github.com/thingsapi/things.py/issues)
         [![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/quality/g/thingsapi/things.py)](https://scrutinizer-ci.com/g/thingsapi/things.py/?branch=master)