Next Generation Taskwarrior Python API.

A simple fork of the stagnant taskw taskwarrior-python bindings.

Sync worklogs between multiple time trackers, invoicing, and bookkeeping software.

Can synchronize for example timewarrior, toggl and clockify which seems pretty nice! Not used it myself since I completely moved to timewarrior.

Very clear visual depiction of how exactly due, scheduled, wait and until work in taskwarrior and, more importantly, how they interact with task recurrence!

A Timewarrior report script for calculating billable hours. - GitHub - trev-dev/timew-billable: A Timewarrior report script for calculating billable hours.

Synchronization between Taskwarrior tasks and services such as Google Calendar, Notion and Google Keep. Formerly taskw_gcal_sync - GitHub - bergercookie/taskwarrior-syncall: Synchronization between Taskwarrior tasks and services such as Google Calendar, Notion and Google Keep. Formerly taskw_gcal_sync

A more user-friendly and a little more powerful alternative to TaskNote - very useful and simple to use.

Some utility functions for timewarrior.

Honestly, I would rather like to see them in timewarrior itself than a standalone script, but they are very useful, providing some command aliases, adding a simple duration syntax, and most importantly allowing to 'restart' a task (you pressed start but did not really yet, just restart at the time you actually start working), or 'restore' (you pressed stop but then continued working on a task, restore is 'continue' which fills the gap in between).

Python library to parse timewarrior data. Has a simple example of creating a csv report, can be used for all sorts of fancy filtering and report creation ideas.

Allows you to add a timewarrior subcommand which displays a nice histogram of past days and a the amount of time you have been working (in general or on something if you filter it).

Works like a normal timewarrior command. Needs some extra dependencies unfortunately.

In-depth workflow example from a longtime taskwarrior user.

Includes explanation of what to do when syncing taskwarrior with other installations (e.g. android) to avoid doubling up of recurring tasks!

Using pipe2 functionality, could presumably be adapted for newsboat, aerc, etc.

Accessing and working with taskwarrior through python

Someday/maybe tasks for taskwarrior with tag urgency coefficients

Adding relative recurring tasks to taskwarrior: they can wait until some time after they have last been completed and they can be due some time after they have last been completed.

Example here:

# You shouldn't mow your lawn more than once a week, but want to keep it short, so shouldn't wait for more than two weeks:

task add 'Mow the Lawn' relativeRecurWait:1weeks relativeRecurDue:2weeks

script to implement GTD workflow better with taskwarrior

• Reminder to do a mini mind sweep, making sure there are no free-floating things
• Project review, where it dumps the pending tasks of each project one by one, and prompts to make any updates (record new tasks, mark tasks done, etc) in another shell
• +next review, where it prompts me to select exactly one +next task for projects that have not exactly one +next task (this is a personal preference)
• Reminder to process e-mail, turn into Taskwarrior items as appropriate in another shell
• Reminder to check last two weeks and next two weeks in calendars, turn into Taskwarrior items as appropriate in another shell
• Dumps my +someday tasks for review
• Dumps my +in tasks, bugs me until they're all gone (by processing them in another shell)
• Runs task sync

I use custom script to store extra information for each task. The following script called note just create a markdown file named by task uuid:

#!/bin/env bash

NOTE_DIR=${HOME}/.task/notes
mkdir -p notes/
if [[ $# -eq 1 ]]; then
  uuid=$(task _get $1.uuid)
  note="${NOTE_DIR}/${uuid}.md"
  vim $note || exit 1
  task ${uuid} mod note:$(date --iso-8601=seconds) >/dev/null
else
  vim ${NOTE_DIR}/buffer
fi

And then just set UDA and alias into taskrc:

uda.note.type=date
uda.note.label=Note
alias.note=execute "${HOME}/.task/hooks/note"

Now you can take a note with vim for each task if necessary:
task note 1
And you may also filter them by UDA:
task note.isnt:
And of course, the best way to manage markdown in vim is vimwiki!

An alternative is taskopen

Can sync between your taskwarrior tasks and caldav instances.

Internally makes use of vdirsync program.
Added as a hook of on-add and on-modify to taskwarrior.
Needs to be compiled first.
Setup looks somewhat involved, but should then just do its work in the background.
Synchronization is then started with caldavwarrior sync, which could be automated via cron/systemd.

Contexts work wonderful for task segregation.
Link contains a simple demonstration of filtering through contexts,
as well as a script with which tags get automatically applied depending on the context one is in (though, does that make sense? I might think of a +Personal task to be done while in my +Work context)

"For your purpose, I would recommend to use contexts based on projects. I use that approach as well and works well with subprojects. Add to your taskrc: context.home: project.hasnt:work context.work: project:work You can switch between contexts: task context work task context home Or completely unset the context to see all tasks independent of the project task context none More about context in the docs For your Jira tickets I would add them to a subproject work.jira so you can filter them by issuing: task project:work.jira Eventually you could just use tags within your project so you can filter them with: task +jira Or a combination of project + tags"

+Tag -> broad life section
project: -> actual project with beginning and end (can be in life section)
+tag -> context of task (where, with whom, etc see GTD)

Good idea for task hierarchy organization in tw:
"I mostly stick with tags, tasks, and subtasks for the structure, with priorities for informal now/soon/eventually scheduling.

Still working out how best to describe broader goals and domains.

Top-level projects kind of work (I have "Site" and "Work" as top-level projects with subprojects for specific projects or narrower domains), but there can be overlap. There's also the "Work is never done" aspect of using top-level projects as domains. It plays hell with your project statistics and keeps that endorphin rush of completion forever out of reach.

I experimented with a UDA for domains. It cluttered things up and was just reinventing tags, poorly.

Current experiment, started about 15 seconds ago: since tags are case-sensitive, use CamelCase to indicate domain: +Work or +Site for example. We'll see how that works out!

And potentially useful tip: tasksh includes a nifty "review" feature for that weekly triage."

A pluggable system for tasklib based TaskWarrior hooks. Faster, less boilerplate code!

Makes it very easy to create taskwarrior hooks in python. Does require a bit of setup however, since it first requires tasklib to exist on the system (/in the environment) and then also requires the taskpirate library.