X-Git-Url: https://git.madduck.net/etc/taskwarrior.git/blobdiff_plain/e9ac4a95bfab8a3e323e15f5f26a6302a87384a3..22b01b5632033b1578d5fc5170d2c048f102f163:/tasklib/task.py diff --git a/tasklib/task.py b/tasklib/task.py index e343583..20bff1f 100644 --- a/tasklib/task.py +++ b/tasklib/task.py @@ -1,19 +1,21 @@ from __future__ import print_function import copy -import datetime +import importlib import json import logging import os import six import sys -from backends import TaskWarrior, TaskWarriorException -from serializing import SerializingObject +from .serializing import SerializingObject DATE_FORMAT = '%Y%m%dT%H%M%SZ' REPR_OUTPUT_SIZE = 10 PENDING = 'pending' COMPLETED = 'completed' +DELETED = 'deleted' +WAITING = 'waiting' +RECURRING = 'recurring' logger = logging.getLogger(__name__) @@ -39,6 +41,11 @@ class ReadOnlyDictView(object): def __len__(self): return len(self.viewed_dict) + def __unicode__(self): + return six.u('ReadOnlyDictView: {0}'.format(repr(self.viewed_dict))) + + __repr__ = __unicode__ + def get(self, key, default=None): return copy.deepcopy(self.viewed_dict.get(key, default)) @@ -76,7 +83,6 @@ class TaskResource(SerializingObject): if update_original: self._original_data = copy.deepcopy(self._data) - def __getitem__(self, key): # This is a workaround to make TaskResource non-iterable # over simple index-based iteration @@ -121,7 +127,7 @@ class TaskResource(SerializingObject): # to pass that to TaskWarrior. data_tuples = filter(lambda t: t[1] is not '', data_tuples) data = dict(data_tuples) - return json.dumps(data, separators=(',',':')) + return json.dumps(data, separators=(',', ':')) @property def _modified_fields(self): @@ -149,7 +155,7 @@ class TaskAnnotation(TaskResource): def __init__(self, task, data=None): self.task = task self._load_data(data or dict()) - super(TaskAnnotation, self).__init__(task.warrior) + super(TaskAnnotation, self).__init__(task.backend) def remove(self): self.task.remove_annotation(self) @@ -162,6 +168,9 @@ class TaskAnnotation(TaskResource): # their data dics are the same return self.task == other.task and self._data == other._data + def __ne__(self, other): + return not self.__eq__(other) + __repr__ = __unicode__ @@ -203,7 +212,7 @@ class Task(TaskResource): pass @classmethod - def from_input(cls, input_file=sys.stdin, modify=None, warrior=None): + def from_input(cls, input_file=sys.stdin, modify=None, backend=None): """ Creates a Task object, directly from the stdin, by reading one line. If modify=True, two lines are used, first line interpreted as the @@ -224,12 +233,13 @@ class Task(TaskResource): modify = name.startswith('on-modify') if modify is None else modify # Create the TaskWarrior instance if none passed - if warrior is None: + if backend is None: + backends = importlib.import_module('tasklib.backends') hook_parent_dir = os.path.dirname(os.path.dirname(sys.argv[0])) - warrior = TaskWarrior(data_location=hook_parent_dir) + backend = backends.TaskWarrior(data_location=hook_parent_dir) # TaskWarrior instance is set to None - task = cls(warrior) + task = cls(backend) # Load the data from the input task._load_data(json.loads(input_file.readline().strip())) @@ -242,8 +252,8 @@ class Task(TaskResource): return task - def __init__(self, warrior, **kwargs): - super(Task, self).__init__(warrior) + def __init__(self, backend, **kwargs): + super(Task, self).__init__(backend) # Check that user is not able to set read-only value in __init__ for key in kwargs.keys(): @@ -273,6 +283,8 @@ class Task(TaskResource): # If the tasks are not saved, compare the actual instances return id(self) == id(other) + def __ne__(self, other): + return not self.__eq__(other) def __hash__(self): if self['uuid']: @@ -298,6 +310,10 @@ class Task(TaskResource): def pending(self): return self['status'] == six.text_type('pending') + @property + def recurring(self): + return self['status'] == six.text_type('recurring') + @property def active(self): return self['start'] is not None @@ -310,20 +326,24 @@ class Task(TaskResource): # Check that all the tasks are saved for task in (cur_dependencies or set()): if not task.saved: - raise Task.NotSaved('Task \'%s\' needs to be saved before ' - 'it can be set as dependency.' % task) + raise Task.NotSaved( + 'Task \'%s\' needs to be saved before ' + 'it can be set as dependency.' % task, + ) return super(Task, self).serialize_depends(cur_dependencies) def delete(self): if not self.saved: - raise Task.NotSaved("Task needs to be saved before it can be deleted") + raise Task.NotSaved( + 'Task needs to be saved before it can be deleted', + ) # Refresh the status, and raise exception if the task is deleted self.refresh(only_fields=['status']) if self.deleted: - raise Task.DeletedTask("Task was already deleted") + raise Task.DeletedTask('Task was already deleted') self.backend.delete_task(self) @@ -332,17 +352,19 @@ class Task(TaskResource): def start(self): if not self.saved: - raise Task.NotSaved("Task needs to be saved before it can be started") + raise Task.NotSaved( + 'Task needs to be saved before it can be started', + ) # Refresh, and raise exception if task is already completed/deleted self.refresh(only_fields=['status']) if self.completed: - raise Task.CompletedTask("Cannot start a completed task") + raise Task.CompletedTask('Cannot start a completed task') elif self.deleted: - raise Task.DeletedTask("Deleted task cannot be started") + raise Task.DeletedTask('Deleted task cannot be started') elif self.active: - raise Task.ActiveTask("Task is already active") + raise Task.ActiveTask('Task is already active') self.backend.start_task(self) @@ -351,13 +373,15 @@ class Task(TaskResource): def stop(self): if not self.saved: - raise Task.NotSaved("Task needs to be saved before it can be stopped") + raise Task.NotSaved( + 'Task needs to be saved before it can be stopped', + ) # Refresh, and raise exception if task is already completed/deleted self.refresh(only_fields=['status']) if not self.active: - raise Task.InactiveTask("Cannot stop an inactive task") + raise Task.InactiveTask('Cannot stop an inactive task') self.backend.stop_task(self) @@ -366,15 +390,17 @@ class Task(TaskResource): def done(self): if not self.saved: - raise Task.NotSaved("Task needs to be saved before it can be completed") + raise Task.NotSaved( + 'Task needs to be saved before it can be completed', + ) # Refresh, and raise exception if task is already completed/deleted self.refresh(only_fields=['status']) if self.completed: - raise Task.CompletedTask("Cannot complete a completed task") + raise Task.CompletedTask('Cannot complete a completed task') elif self.deleted: - raise Task.DeletedTask("Deleted task cannot be completed") + raise Task.DeletedTask('Deleted task cannot be completed') self.backend.complete_task(self) @@ -390,14 +416,14 @@ class Task(TaskResource): def add_annotation(self, annotation): if not self.saved: - raise Task.NotSaved("Task needs to be saved to add annotation") + raise Task.NotSaved('Task needs to be saved to add annotation') self.backend.annotate_task(self, annotation) self.refresh(only_fields=['annotations']) def remove_annotation(self, annotation): if not self.saved: - raise Task.NotSaved("Task needs to be saved to remove annotation") + raise Task.NotSaved('Task needs to be saved to remove annotation') if isinstance(annotation, TaskAnnotation): annotation = annotation['description'] @@ -408,32 +434,34 @@ class Task(TaskResource): def refresh(self, only_fields=None, after_save=False): # Raise error when trying to refresh a task that has not been saved if not self.saved: - raise Task.NotSaved("Task needs to be saved to be refreshed") + raise Task.NotSaved('Task needs to be saved to be refreshed') new_data = self.backend.refresh_task(self, after_save=after_save) if only_fields: to_update = dict( - [(k, new_data.get(k)) for k in only_fields]) + [(k, new_data.get(k)) for k in only_fields], + ) self._update_data(to_update, update_original=True) else: self._load_data(new_data) + class TaskQuerySet(object): """ Represents a lazy lookup for a task objects. """ - def __init__(self, warrior=None, filter_obj=None): - self.warrior = warrior + def __init__(self, backend, filter_obj=None): + self.backend = backend self._result_cache = None - self.filter_obj = filter_obj or self.warrior.filter_class(warrior) + self.filter_obj = filter_obj or self.backend.filter_class(backend) def __deepcopy__(self, memo): """ Deep copy of a QuerySet doesn't populate the cache """ - obj = self.__class__() + obj = self.__class__(backend=self.backend) for k, v in self.__dict__.items(): if k in ('_iter', '_result_cache'): obj.__dict__[k] = None @@ -444,7 +472,7 @@ class TaskQuerySet(object): def __repr__(self): data = list(self[:REPR_OUTPUT_SIZE + 1]) if len(data) > REPR_OUTPUT_SIZE: - data[-1] = "...(remaining elements truncated)..." + data[-1] = '...(remaining elements truncated)...' return repr(data) def __len__(self): @@ -478,7 +506,7 @@ class TaskQuerySet(object): if klass is None: klass = self.__class__ filter_obj = self.filter_obj.clone() - c = klass(warrior=self.warrior, filter_obj=filter_obj) + c = klass(backend=self.backend, filter_obj=filter_obj) c.__dict__.update(kwargs) return c @@ -486,7 +514,7 @@ class TaskQuerySet(object): """ Fetch the tasks which match the current filters. """ - return self.warrior.filter_tasks(self.filter_obj) + return self.backend.filter_tasks(self.filter_obj) def all(self): """ @@ -500,6 +528,15 @@ class TaskQuerySet(object): def completed(self): return self.filter(status=COMPLETED) + def deleted(self): + return self.filter(status=DELETED) + + def waiting(self): + return self.filter(status=WAITING) + + def recurring(self): + return self.filter(status=RECURRING) + def filter(self, *args, **kwargs): """ Returns a new TaskQuerySet with the given filters added. @@ -523,7 +560,9 @@ class TaskQuerySet(object): if not num: raise Task.DoesNotExist( 'Task matching query does not exist. ' - 'Lookup parameters were {0}'.format(kwargs)) + 'Lookup parameters were {0}'.format(kwargs), + ) raise ValueError( 'get() returned more than one Task -- it returned {0}! ' - 'Lookup parameters were {1}'.format(num, kwargs)) + 'Lookup parameters were {1}'.format(num, kwargs), + )