Update README.me to v2.0

Build and publish Docker image in GitHub actions

.github/workflows/ci.yaml

@@ -0,0 +1,41 @@
+name: Build and publish Docker image
+
+on:
+  push:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-publish-docker-image:
+    name: Build and publish Docker image
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v1
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -57,4 +57,8 @@ target/
 # IDEA
 .idea/
 
-.env
+.env
+
+# VSCODE
+.json
+.vscode

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3-slim-bullseye
+
+WORKDIR /usr/src/app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENTRYPOINT [ "python", "./autodoist.py" ]

Procfile

@@ -1 +0,0 @@
-nextaction: python nextaction.py -a $TODOIST_API_KEY -l $TODOIST_NEXT_ACTION_LABEL $DEBUG --nocache

README.md

@@ -1,40 +1,195 @@
-NextAction
-==========
+# Autodoist
 
-A more GTD-like workflow for Todoist. Uses the REST API to add and remove a `@next_action` label from tasks.
+*Note: v2.0 is a major overhaul of Autodoist, so please be sure to view the README in order to get up to speed with the latest changes. Thanks to everyone for helping out and supporting this project!*
 
-This program looks at every list in your Todoist account.
-Any list that ends with `_` or `.` is treated specially, and processed by NextAction.
+This program adds four major functionalities to Todoist to help automate your workflow:
 
-Note that NextAction requires Todoist Premium to function properly, as labels are a premium feature.
+1) Assign automatic `@next_action` labels for a more GTD-like workflow
+   - Flexible options to label tasks sequentially or in parallel
+   - Limit labels based on a start-date or hide future tasks based on the due date
+2) [Temporary disabled] Enable regeneration of sub-tasks in lists with a recurring date. Multiple modes possible.
+3) Postpone the end-of-day time to after midnight to finish your daily recurring tasks
+4) Make multiple tasks (un)checkable at the same time
 
-Requirements
-============
+If this tool helped you out, I would really appreciate your support by providing me with some coffee!
 
-* Python 2.7, Python 3.0+ is unsupported at the moment
-* ```todoist-python``` package.
+<a href=https://ko-fi.com/hoffelhas>
+ <img src="https://i.imgur.com/MU1rAPG.png" width="150">
+</a>
 
-Activating NextAction
-=====================
+# Requirements
 
-Sequential list processing
---------------------------
-If a project or task ends with `_`, the child tasks will be treated as a priority queue and the most important will be labeled `@next_action`.
-Importance is determined by order in the list
+Autodoist has been build with Python 3.11.1, which is the recommended version. Older versions of 3.x should be compatible, however be aware that they have not been tested.
 
-Parallel list processing
-------------------------
-If a project or task name ends with `.`, the child tasks will be treated as parallel `@next_action`s.
-The waterfall processing will be applied the same way as sequential lists - every parent task will be treated as sequential. This can be overridden by appending `_` to the name of the parent task.
+To run Autodoist the following packages are required:
+* ```todoist-python```
+* ```requests```
 
-Executing NextAction
-====================
+For your convenience a requirements.txt is provided, which allows you to install them by using pip:
 
-You can run NexAction from any system that supports Python.
+`pip install -r requirements.txt`
 
-Running NextAction
-------------------
+# 1. Automatic next action labels
 
-NextAction will read your environment to retrieve your Todoist API key, so to run on a Linux/Mac OSX you can use the following commandline
+The program looks for pre-defined tags in the name of every project, section, or parentless tasks in your Todoist account to automatically add and remove `@next_action` labels.
 
-    python nextaction.py -a <API Key>
+Projects, sections, and parentless tasks can be tagged independently of each other to create the required functionality. If this tag is not defined, it will not activate this functionality. The result will be a clear, current and comprehensive list of next actions without the need for further thought.
+
+See the example given at [running Autodoist](#running-autodoist) on how to run this mode. If the label does not exist yet in your Todoist, a possibility is given to automatically create it.
+
+## Useful filter tip
+
+For a more GTD-like workflow, you can use Todoist filters to create a clean and cohesive list that only contains your actionable tasks. As a simple example, you could use the following filter:
+
+`@next_action & #PROJECT_NAME`
+
+## Sequential processing
+
+If a project, section, or parentless task ends with a dash `-`, the tasks will be treated sequentially in a priority queue, where only the first task that is found is labeled. If a task contains sub-tasks, the first lowest task is labeled instead.
+
+![Sequential task labeling](https://i.imgur.com/ZUKbA8E.gif)
+
+## Parallel processing
+
+If a project, section, or parentless task name ends with an equal sign `=`, all tasks will be treated in parallel. A waterfall processing is applied, where the lowest possible (sub-)tasks are labelled.
+
+![Parallel task labeling](https://i.imgur.com/xZZ0kEM.gif)
+
+## Advanced labelling
+
+Projects, sections, and (parentless) tasks can be used to specify how the levels under them should behave. This means that:
+
+- A project can accept up to three tags, to specify how the sections, parentless tasks, and subtasks should behave.
+- A section can accept up to two tags, to specify parentless tasks and subtasks should behave.
+- A task at any level can be labelled with one tag, to specify how its sub-tasks should behave.
+
+Tags can be applied on each level simultaneously, where the lower level setting will always override the one specified in the levels above.
+
+### Shorthand notation
+
+If fewer tags then needed are specified, the last one is simply copied. E.g. if a project has the tag `=` this is similar to `===`, or if a project has `=-` this is similar to `=--`. Same for sections, `=` is similar to `==`.
+
+### Project labeling examples
+- If a project ends with `---`, only the first section has tasks that are handled sequentially.
+- If a project ends with `=--`, all sections have tasks that are handled sequentially.
+- If a project ends with `-=-`, only the first section has parallel parentless tasks with sequential sub-tasks.
+- If a project ends with `--=`, only the first section and first parentless tasks has parallel sub-tasks.
+- If a project ends with `==-`, all sections and all parentless tasks will have sub-tasks are handled sequentially.
+- If a project ends with `=-=`, all sections will have parentless tasks that are processed sequentially, but all sub-tasks are handled in parallel.
+- If a project ends with `-==`, only the first section has parallel tasks.
+- If a project ends with `===`, all tasks are handled in parallel.
+
+### Section labeling examples
+- If a section ends with `--`, only the first parentless task will have sub-tasks that are handled sequentially.
+- If a section ends with `=-`, all parentless tasks will have sub-tasks that are handled sequentially.
+- If a section ends with `-=`, only the first parentless task has sub-tasks that are handled in parallel.
+- If a section ends with `==`, all tasks are handled in parallel.
+
+### Tasks labeling examples
+- If a task ends with `-`, the sub-tasks are handled sequentially.
+- If a task ends with `=`, the sub-tasks are handled in parallel.
+
+### Kanban board labeling
+A standard workflow for Kanban boards is to have one actionable task per column/section, which is then moved to the next column when needed. Most often, the most right column is the 'done' section. To ensure that every column only has one labelled task and the last column contains no labelled tasks, you could do either of two things:
+- Add the `=--` tag to the project name, and disable labelling for the 'done' section by adding `*` to either the start or end of the section name.
+- Add the `--` tag to every section that you want to have labels.
+
+
+## Start/Due date enhanced experience
+
+Two methods are provided to hide tasks that are not relevant yet.
+
+- Prevent labels by defining a start-date that is added to the task itself. The label is only assigned if this date is reached. You can define the start-date by adding 'start=DD-MM-YYYY'. On the other hand, the start date can be defined as several days or weeks before the due-date by using either 'start=due-<NUMBER_OF_DAYS>d' or 'start=due-<NUMBER_OF_WEEKS>w'. This is especially useful for recurring tasks!
+   [See an example of using start-dates](https://i.imgur.com/WJRoJzW.png).
+
+- Prevent labels of all tasks if the due date is too far in the future. Define the amount by running with the argument '-hf <NUMBER_OF_DAYS>'.
+[See an example of the hide-future functionality](https://i.imgur.com/LzSoRUm.png).
+
+# 2. Regenerate sub-tasks in recurring lists
+
+*DISCLAIMER: This feature has been disabled for now due to two reasons:*
+- *Regeneration is a [core feature of Todoist nowadays](https://todoist.com/help/articles/can-i-reset-sub-tasks). This was made possible thanks to all of you who are using and supporting Autodoist, which resulted in Doist to include this too! Thank you all for making this happen!*
+- *In the new REST API v2 it's currently not possible to see completed tasks, which makes regeneration a bit difficult.*
+
+*Nevertheless, the Todoist implementation is still more limited than Autodoist, it does not restore the original order of the sub-tasks, and deeper sub-tasks can't be reset. I therefore believe it is still useful for this feature to be re-enabled in the near future.*
+
+Autodoist looks for all parentless tasks with a recurring date. If they contain sub-tasks, they will be regenerated in the same order when the parentless task is checked.
+
+![See example](https://i.imgur.com/WKKd14o.gif)
+
+To give you more flexibility, multiple modes are provided:
+1. No regeneration
+2. Checking the main task regenerates all sub-tasks
+3. Checking the main task regenerates all sub-tasks only if all sub-tasks have been checked first
+
+When this functionality is activated, it is possible to chose which mode is used as overall functionality for your Todoist. See the example given at [running Autodoist](#running-autodoist).
+
+In addition you can override the overall mode by adding the labels `Regen_off`, `Regen_all`, or `Regen_all_if_completed` to one of your main recurring task. These labels will automatically be created for you.
+
+# 3. Postpone the end-of-day
+
+You have a daily recurring task, but you're up working late and now it's past midnight. When this happens, Todoist will automatically mark it overdue and when checked by you it moves to tomorrow. This means that after a good night's rest you can't complete the task that day!
+
+By setting an alternative time for the end-of-day you can now finish your work after midnight and the new date will automatically be corrected for you.
+
+![See example 1](https://i.imgur.com/tvnTMOJ.gif)
+
+# 4. Make multiple tasks uncheckable / re-checkable at the same time
+
+Todoist allows the asterisk symbol `* ` to be used to ensure tasks can't be checked by turning them into headers. Now you are able to do this en masse!
+
+Simply add `** ` or `-* ` in front of a project, section, or parentless task to automatically turn all the tasks that it includes into respectively headers or checkable tasks.
+
+# Executing Autodoist
+
+You can run Autodoist from any system that supports Python.
+
+## Running Autodoist
+
+Autodoist will read your environment to retrieve your Todoist API key and additional arguments. In order to run on Windows/Linux/Mac OSX you can use the following command lines.
+    
+If you want to enable labelling mode, run with the `-l` argument:
+
+    python autodoist.py -a <API Key> -l <LABEL_NAME>
+    
+If you want to enable regeneration of sub-tasks in recurring lists, run with the `-r` argument followed by a mode number for the overall functionality (1: no regeneration, 2: regenerate all, 3: regenerate only if all sub-tasks are completed):
+
+    python autodoist.py -a <API Key> -r <NUMBER>
+    
+If you want to enable an alternative end-of-day, run with the `-e` argument and a number from 1 to 24 to specify which hour:
+
+    python autodoist.py -a <API Key> -e <NUMBER>
+    
+These modes can be run individually, or combined with each other.
+
+## Additional arguments
+
+Several additional arguments can be provided, for example to change the suffix tags for parallel and sequential projects:
+
+    python autodoist.py --p_suffix <tag>
+    python autodoist.py --s_suffix <tag>
+    
+Note: Be aware that Todoist sections don't like to have a slash '/' in the name, which will automatically change to an underscore. Detection of the tag will not work. 
+    
+If you want to hide all tasks due in the future:
+
+    python autodoist.py --hf <NUMBER_OF_DAYS>
+
+In addition, if you experience issues with syncing you can increase the api syncing time (default 5 seconds):
+    
+    python autodoist.py --delay <time in seconds>
+
+For all arguments, please check out the help:
+
+    python autodoist.py --help
+
+
+## Docker container
+
+To build the docker container, check out the repository and run:
+
+    docker build . --tag autodoist:latest
+
+To run autodoist inside the docker container:
+
+    docker run -it autodoist:latest

nextaction.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python
-
-import logging
-import argparse
-
-from todoist.api import TodoistAPI
-
-import time
-import sys
-from datetime import datetime
-
-CHECKED = 1
-
-
-def main():
-    """Main process function."""
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-a', '--api_key', help='Todoist API Key')
-    parser.add_argument('-l', '--label', help='The next action label to use', default='next_action')
-    parser.add_argument('-d', '--delay', help='Specify the delay in seconds between syncs', default=5, type=int)
-    parser.add_argument('--debug', help='Enable debugging', action='store_true')
-    parser.add_argument('--inbox', help='The method the Inbox project should be processed',
-                        default='parallel', choices=['parallel', 'serial'])
-    parser.add_argument('--parallel_suffix', default='.')
-    parser.add_argument('--serial_suffix', default='_')
-    parser.add_argument('--hide_future', help='Hide future dated next actions until the specified number of days',
-                        default=7, type=int)
-    parser.add_argument('--onetime', help='Update Todoist once and exit', action='store_true')
-    parser.add_argument('--nocache', help='Disables caching data to disk for quicker syncing', action='store_true')
-    args = parser.parse_args()
-
-    # Set debug
-    if args.debug:
-        log_level = logging.DEBUG
-    else:
-        log_level = logging.INFO
-    logging.basicConfig(level=log_level)
-
-    # Check we have a API key
-    if not args.api_key:
-        logging.error('No API key set, exiting...')
-        sys.exit(1)
-
-    # Run the initial sync
-    logging.debug('Connecting to the Todoist API')
-
-    api_arguments = {'token': args.api_key}
-    if args.nocache:
-        logging.debug('Disabling local caching')
-        api_arguments['cache'] = None
-
-    api = TodoistAPI(**api_arguments)
-    logging.debug('Syncing the current state from the API')
-    api.sync()
-
-    # Check the next action label exists
-    labels = api.labels.all(lambda x: x['name'] == args.label)
-    if len(labels) > 0:
-        label_id = labels[0]['id']
-        logging.debug('Label \'%s\' found as label id %d', args.label, label_id)
-    else:
-        logging.error("Label \'%s\' doesn't exist, please create it or change TODOIST_NEXT_ACTION_LABEL.", args.label)
-        sys.exit(1)
-
-    def get_project_type(project_object):
-        """Identifies how a project should be handled."""
-        name = project_object['name'].strip()
-        if name == 'Inbox':
-            return args.inbox
-        elif name[-1] == args.parallel_suffix:
-            return 'parallel'
-        elif name[-1] == args.serial_suffix:
-            return 'serial'
-
-    def get_item_type(item):
-        """Identifies how a item with sub items should be handled."""
-        name = item['content'].strip()
-        if name[-1] == args.parallel_suffix:
-            return 'parallel'
-        elif name[-1] == args.serial_suffix:
-            return 'serial'
-
-    def add_label(item, label):
-        if label not in item['labels']:
-            labels = item['labels']
-            logging.debug('Updating \'%s\' with label', item['content'])
-            labels.append(label)
-            api.items.update(item['id'], labels=labels)
-
-    def remove_label(item, label):
-        if label in item['labels']:
-            labels = item['labels']
-            logging.debug('Updating \'%s\' without label', item['content'])
-            labels.remove(label)
-            api.items.update(item['id'], labels=labels)
-
-    # Main loop
-    while True:
-        try:
-            api.sync()
-        except Exception as e:
-            logging.exception('Error trying to sync with Todoist API: %s' % str(e))
-        else:
-            for project in api.projects.all():
-                project_type = get_project_type(project)
-                if project_type:
-                    logging.debug('Project \'%s\' being processed as %s', project['name'], project_type)
-
-                    # Get all items for the project
-                    items = sorted(api.items.all(lambda x: x['project_id'] == project['id']),
-                                   key=lambda x: x['child_order'])
-                    # filter for completable items
-                    items = list(filter(lambda x: not x['content'].startswith('*'), items))
-
-                    first_found = False
-
-                    for item in items:
-
-                        # If its too far in the future, remove the next_action tag and skip
-                        if args.hide_future > 0 and 'due_date_utc' in item.data and item['due_date_utc'] is not None:
-                            due_date = datetime.strptime(item['due_date_utc'], '%a %d %b %Y %H:%M:%S +0000')
-                            future_diff = (due_date - datetime.utcnow()).total_seconds()
-                            if future_diff >= (args.hide_future * 86400):
-                                remove_label(item, label_id)
-                                continue
-
-                        if item['parent_id'] is None:
-                            if project_type == 'serial':
-                                if not first_found:
-                                    add_label(item, label_id)
-                                    first_found = True
-                                else:
-                                    remove_label(item, label_id)
-                            elif project_type == 'parallel':
-                                add_label(item, label_id)
-
-                        item_type = get_item_type(item)
-                        child_items = list(filter(lambda x: x['parent_id'] == item['id'], items))
-                        if item_type:
-                            logging.debug('Identified \'%s\' as %s type', item['content'], item_type)
-
-                        if item_type or len(child_items) > 0:
-                            if label_id in item['labels']:
-                                # Process serial tagged items
-                                if item_type == 'serial':
-                                    child_first_found = False
-                                    for child_item in child_items:
-                                        if child_item['checked'] == 0 and not child_first_found:
-                                            add_label(child_item, label_id)
-                                            child_first_found = True
-                                        else:
-                                            remove_label(child_item, label_id)
-                                # Process parallel tagged items or untagged parents
-                                elif item_type == 'parallel':
-                                    for child_item in child_items:
-                                        add_label(child_item, label_id)
-
-                                # Remove the label from the parent
-                                remove_label(item, label_id)
-                            else:
-                                for child_item in child_items:
-                                    remove_label(child_item, label_id)
-
-            if len(api.queue):
-                logging.debug('%d changes queued for sync... commiting to Todoist.', len(api.queue))
-                api.commit()
-            else:
-                logging.debug('No changes queued, skipping sync.')
-
-        # If onetime is set, exit after first execution.
-        if args.onetime:
-            break
-
-        logging.debug('Sleeping for %d seconds', args.delay)
-        time.sleep(args.delay)
-
-
-if __name__ == '__main__':
-    main()

requirements.txt

@@ -1 +1,2 @@
-todoist-python>=8.1.1
+requests==2.28.1
+todoist_api_python==2.0.2

setup.py

@@ -1,20 +1,16 @@
 from setuptools import setup
 
 setup(
-    name='NextAction',
-    version='0.5',
-    py_modules=['nextaction'],
-    url='https://github.com/nikdoof/NextAction',
+    name='autodoist',
+    version='2.0',
+    py_modules=['autodoist'],
+    url='https://github.com/Hoffelhas/automation-todoist',
     license='MIT',
-    author='Andrew Williams',
-    author_email='andy@tensixtyone.com',
-    description='A more GTD-like workflow for Todoist. Uses the REST API to add and remove a @next_action label from tasks.',
-    entry_points={
-        "console_scripts": [
-            "nextaction=nextaction:main",
-        ],
-    },
+    author='Alexander Haselhoff',
+    author_email='xela@live.nl',
+    description='Added functionality for Todoist: 1) next-action labels, 2) sub-task regeneration, 3) postpone end of day, and 4) (un)header items simultaneously)',
     install_requires=[
         'todoist-python',
+        'requests',
     ]
 )