]> git.madduck.net Git - etc/taskwarrior.git/blobdiff - tasklib/task.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Task: Do not yield corner case of fake removals as modified field
[etc/taskwarrior.git] / tasklib / task.py
index 9a02f35e6811c22d17f43e5796c678346ce2295d..f61fb056591c3afb22486ad62a30f78c586c8918 100644 (file)
@@ -1,8 +1,10 @@
+from __future__ import print_function
 import copy
 import datetime
 import json
 import logging
 import os
 import copy
 import datetime
 import json
 import logging
 import os
+import six
 import subprocess
 
 DATE_FORMAT = '%Y%m%dT%H%M%SZ'
 import subprocess
 
 DATE_FORMAT = '%Y%m%dT%H%M%SZ'
@@ -10,6 +12,11 @@ REPR_OUTPUT_SIZE = 10
 PENDING = 'pending'
 COMPLETED = 'completed'
 
 PENDING = 'pending'
 COMPLETED = 'completed'
 
+VERSION_2_1_0 = six.u('2.1.0')
+VERSION_2_2_0 = six.u('2.2.0')
+VERSION_2_3_0 = six.u('2.3.0')
+VERSION_2_4_0 = six.u('2.4.0')
+
 logger = logging.getLogger(__name__)
 
 
 logger = logging.getLogger(__name__)
 
 
@@ -17,84 +24,419 @@ class TaskWarriorException(Exception):
     pass
 
 
     pass
 
 
-class Task(object):
-
-    class DoesNotExist(Exception):
-        pass
-
-    def __init__(self, warrior, data={}):
-        self.warrior = warrior
-        self._data = data
-        print data
-        self._modified_fields = set()
-
-    def __unicode__(self):
-        return self['description']
+class SerializingObject(object):
+    """
+    Common ancestor for TaskResource & TaskFilter, since they both
+    need to serialize arguments.
+    """
 
 
-    def __getitem__(self, key):
+    def _deserialize(self, key, value):
         hydrate_func = getattr(self, 'deserialize_{0}'.format(key),
         hydrate_func = getattr(self, 'deserialize_{0}'.format(key),
-                               lambda x: x)
-        return hydrate_func(self._data.get(key))
+                               lambda x: x if x != '' else None)
+        return hydrate_func(value)
 
 
-    def __setitem__(self, key, value):
+    def _serialize(self, key, value):
         dehydrate_func = getattr(self, 'serialize_{0}'.format(key),
         dehydrate_func = getattr(self, 'serialize_{0}'.format(key),
-                                 lambda x: x)
-        self._data[key] = dehydrate_func(value)
-        self._modified_fields.add(key)
+                                 lambda x: x if x is not None else '')
+        return dehydrate_func(value)
 
 
-    def serialize_due(self, date):
+    def timestamp_serializer(self, date):
+        if not date:
+            return None
         return date.strftime(DATE_FORMAT)
 
         return date.strftime(DATE_FORMAT)
 
-    def deserialize_due(self, date_str):
+    def timestamp_deserializer(self, date_str):
         if not date_str:
             return None
         return datetime.datetime.strptime(date_str, DATE_FORMAT)
 
         if not date_str:
             return None
         return datetime.datetime.strptime(date_str, DATE_FORMAT)
 
-    def serialize_annotations(self, annotations):
-        ann_list = list(annotations)
-        for ann in ann_list:
-            ann['entry'] = ann['entry'].strftime(DATE_FORMAT)
-        return ann_list
+    def serialize_entry(self, value):
+        return self.timestamp_serializer(value)
 
 
-    def deserialize_annotations(self, annotations):
-        ann_list = list(annotations)
-        for ann in ann_list:
-            ann['entry'] = datetime.datetime.strptime(
-                ann['entry'], DATE_FORMAT)
-        return ann_list
+    def deserialize_entry(self, value):
+        return self.timestamp_deserializer(value)
 
 
-    def deserialize_tags(self, tags):
-        if isinstance(tags, basestring):
-            return tags.split(',') if tags else []
-        return tags
+    def serialize_modified(self, value):
+        return self.timestamp_serializer(value)
+
+    def deserialize_modified(self, value):
+        return self.timestamp_deserializer(value)
+
+    def serialize_due(self, value):
+        return self.timestamp_serializer(value)
+
+    def deserialize_due(self, value):
+        return self.timestamp_deserializer(value)
+
+    def serialize_scheduled(self, value):
+        return self.timestamp_serializer(value)
+
+    def deserialize_scheduled(self, value):
+        return self.timestamp_deserializer(value)
+
+    def serialize_until(self, value):
+        return self.timestamp_serializer(value)
+
+    def deserialize_until(self, value):
+        return self.timestamp_deserializer(value)
+
+    def serialize_wait(self, value):
+        return self.timestamp_serializer(value)
+
+    def deserialize_wait(self, value):
+        return self.timestamp_deserializer(value)
+
+    def deserialize_annotations(self, data):
+        return [TaskAnnotation(self, d) for d in data] if data else []
 
     def serialize_tags(self, tags):
         return ','.join(tags) if tags else ''
 
 
     def serialize_tags(self, tags):
         return ','.join(tags) if tags else ''
 
+    def deserialize_tags(self, tags):
+        if isinstance(tags, six.string_types):
+            return tags.split(',') if tags else []
+        return tags or []
+
+    def serialize_depends(self, cur_dependencies):
+        # Return the list of uuids
+        return ','.join(task['uuid'] for task in cur_dependencies)
+
+    def deserialize_depends(self, raw_uuids):
+        raw_uuids = raw_uuids or ''  # Convert None to empty string
+        uuids = raw_uuids.split(',')
+        return set(self.warrior.tasks.get(uuid=uuid) for uuid in uuids if uuid)
+
+
+class TaskResource(SerializingObject):
+    read_only_fields = []
+
+    def _load_data(self, data):
+        self._data = dict((key, self._deserialize(key, value))
+                          for key, value in data.items())
+        # We need to use a copy for original data, so that changes
+        # are not propagated.
+        self._original_data = copy.deepcopy(self._data)
+
+    def _update_data(self, data, update_original=False):
+        """
+        Low level update of the internal _data dict. Data which are coming as
+        updates should already be serialized. If update_original is True, the
+        original_data dict is updated as well.
+        """
+        self._data.update(dict((key, self._deserialize(key, value))
+                               for key, value in data.items()))
+
+        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
+        try:
+            int(key)
+            raise StopIteration
+        except ValueError:
+            pass
+
+        if key not in self._data:
+            self._data[key] = self._deserialize(key, None)
+
+        return self._data.get(key)
+
+    def __setitem__(self, key, value):
+        if key in self.read_only_fields:
+            raise RuntimeError('Field \'%s\' is read-only' % key)
+        self._data[key] = value
+
+    def __str__(self):
+        s = six.text_type(self.__unicode__())
+        if not six.PY3:
+            s = s.encode('utf-8')
+        return s
+
+    def __repr__(self):
+        return str(self)
+
+
+class TaskAnnotation(TaskResource):
+    read_only_fields = ['entry', 'description']
+
+    def __init__(self, task, data={}):
+        self.task = task
+        self._load_data(data)
+
+    def remove(self):
+        self.task.remove_annotation(self)
+
+    def __unicode__(self):
+        return self['description']
+
+    def __eq__(self, other):
+        # consider 2 annotations equal if they belong to the same task, and
+        # their data dics are the same
+        return self.task == other.task and self._data == other._data
+
+    __repr__ = __unicode__
+
+
+class Task(TaskResource):
+    read_only_fields = ['id', 'entry', 'urgency', 'uuid', 'modified']
+
+    class DoesNotExist(Exception):
+        pass
+
+    class CompletedTask(Exception):
+        """
+        Raised when the operation cannot be performed on the completed task.
+        """
+        pass
+
+    class DeletedTask(Exception):
+        """
+        Raised when the operation cannot be performed on the deleted task.
+        """
+        pass
+
+    class NotSaved(Exception):
+        """
+        Raised when the operation cannot be performed on the task, because
+        it has not been saved to TaskWarrior yet.
+        """
+        pass
+
+    def __init__(self, warrior, **kwargs):
+        self.warrior = warrior
+
+        # Check that user is not able to set read-only value in __init__
+        for key in kwargs.keys():
+            if key in self.read_only_fields:
+                raise RuntimeError('Field \'%s\' is read-only' % key)
+
+        # We serialize the data in kwargs so that users of the library
+        # do not have to pass different data formats via __setitem__ and
+        # __init__ methods, that would be confusing
+
+        # Rather unfortunate syntax due to python2.6 comaptiblity
+        self._load_data(dict((key, self._serialize(key, value))
+                        for (key, value) in six.iteritems(kwargs)))
+
+    def __unicode__(self):
+        return self['description']
+
+    def __eq__(self, other):
+        if self['uuid'] and other['uuid']:
+            # For saved Tasks, just define equality by equality of uuids
+            return self['uuid'] == other['uuid']
+        else:
+            # If the tasks are not saved, compare the actual instances
+            return id(self) == id(other)
+
+
+    def __hash__(self):
+        if self['uuid']:
+            # For saved Tasks, just define equality by equality of uuids
+            return self['uuid'].__hash__()
+        else:
+            # If the tasks are not saved, return hash of instance id
+            return id(self).__hash__()
+
+    @property
+    def _modified_fields(self):
+        writable_fields = set(self._data.keys()) - set(self.read_only_fields)
+        for key in writable_fields:
+            new_value = self._data.get(key)
+            old_value = self._original_data.get(key)
+
+            # Make sure not to mark data removal as modified field if the
+            # field originally had some empty value
+            if key in self._data and not new_value and not old_value:
+                continue
+
+            if new_value != old_value:
+                yield key
+
+    @property
+    def _is_modified(self):
+        return bool(list(self._modified_fields))
+
+    @property
+    def completed(self):
+        return self['status'] == six.text_type('completed')
+
+    @property
+    def deleted(self):
+        return self['status'] == six.text_type('deleted')
+
+    @property
+    def waiting(self):
+        return self['status'] == six.text_type('waiting')
+
+    @property
+    def pending(self):
+        return self['status'] == six.text_type('pending')
+
+    @property
+    def saved(self):
+        return self['uuid'] is not None or self['id'] is not None
+
+    def serialize_depends(self, cur_dependencies):
+        # Check that all the tasks are saved
+        for task in cur_dependencies:
+            if not task.saved:
+                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 format_depends(self):
+        # We need to generate added and removed dependencies list,
+        # since Taskwarrior does not accept redefining dependencies.
+
+        # This cannot be part of serialize_depends, since we need
+        # to keep a list of all depedencies in the _data dictionary,
+        # not just currently added/removed ones
+
+        old_dependencies = self._original_data.get('depends', set())
+
+        added = self['depends'] - old_dependencies
+        removed = old_dependencies - self['depends']
+
+        # Removed dependencies need to be prefixed with '-'
+        return 'depends:' + ','.join(
+                [t['uuid'] for t in added] +
+                ['-' + t['uuid'] for t in removed]
+            )
+
+    def format_description(self):
+        # Task version older than 2.4.0 ignores first word of the
+        # task description if description: prefix is used
+        if self.warrior.version < VERSION_2_4_0:
+            return self._data['description']
+        else:
+            return "description:'{0}'".format(self._data['description'] or '')
+
     def delete(self):
     def delete(self):
-        self.warrior.execute_command([self['id'], 'delete'], config_override={
-            'confirmation': 'no',
-        })
+        if not self.saved:
+            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")
+
+        self.warrior.execute_command([self['uuid'], 'delete'])
+
+        # Refresh the status again, so that we have updated info stored
+        self.refresh(only_fields=['status'])
+
 
     def done(self):
 
     def done(self):
-        self.warrior.execute_command([self['id'], 'done'])
+        if not self.saved:
+            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")
+        elif self.deleted:
+            raise Task.DeletedTask("Deleted task cannot be completed")
+
+        self.warrior.execute_command([self['uuid'], 'done'])
+
+        # Refresh the status again, so that we have updated info stored
+        self.refresh(only_fields=['status'])
 
     def save(self):
 
     def save(self):
-        args = [self['id'], 'modify'] if self['id'] else ['add']
+        if self.saved and not self._is_modified:
+            return
+
+        args = [self['uuid'], 'modify'] if self.saved else ['add']
         args.extend(self._get_modified_fields_as_args())
         args.extend(self._get_modified_fields_as_args())
+        output = self.warrior.execute_command(args)
+
+        # Parse out the new ID, if the task is being added for the first time
+        if not self.saved:
+            id_lines = [l for l in output if l.startswith('Created task ')]
+
+            # Complain loudly if it seems that more tasks were created
+            # Should not happen
+            if len(id_lines) != 1 or len(id_lines[0].split(' ')) != 3:
+                raise TaskWarriorException("Unexpected output when creating "
+                                           "task: %s" % '\n'.join(id_lines))
+
+            # Circumvent the ID storage, since ID is considered read-only
+            self._data['id'] = int(id_lines[0].split(' ')[2].rstrip('.'))
+
+        self.refresh()
+
+    def add_annotation(self, annotation):
+        if not self.saved:
+            raise Task.NotSaved("Task needs to be saved to add annotation")
+
+        args = [self['uuid'], 'annotate', annotation]
+        self.warrior.execute_command(args)
+        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")
+
+        if isinstance(annotation, TaskAnnotation):
+            annotation = annotation['description']
+        args = [self['uuid'], 'denotate', annotation]
         self.warrior.execute_command(args)
         self.warrior.execute_command(args)
-        self._modified_fields.clear()
+        self.refresh(only_fields=['annotations'])
 
     def _get_modified_fields_as_args(self):
         args = []
 
     def _get_modified_fields_as_args(self):
         args = []
-        for field in self._modified_fields:
-            args.append('{}:{}'.format(field, self._data[field]))
-        return args
 
 
-    __repr__ = __unicode__
+        def add_field(field):
+            # Add the output of format_field method to args list (defaults to
+            # field:value)
+            serialized_value = self._serialize(field, self._data[field]) or ''
+            format_default = lambda: "{0}:{1}".format(
+                field,
+                "'{0}'".format(serialized_value) if serialized_value else ''
+            )
+            format_func = getattr(self, 'format_{0}'.format(field),
+                                  format_default)
+            args.append(format_func())
+
+        # If we're modifying saved task, simply pass on all modified fields
+        if self.saved:
+            for field in self._modified_fields:
+                add_field(field)
+        # For new tasks, pass all fields that make sense
+        else:
+            for field in self._data.keys():
+                if field in self.read_only_fields:
+                    continue
+                add_field(field)
 
 
+        return args
 
 
-class TaskFilter(object):
+    def refresh(self, only_fields=[]):
+        # 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")
+
+        # We need to use ID as backup for uuid here for the refreshes
+        # of newly saved tasks. Any other place in the code is fine
+        # with using UUID only.
+        args = [self['uuid'] or self['id'], 'export']
+        new_data = json.loads(self.warrior.execute_command(args)[0])
+        if only_fields:
+            to_update = dict(
+                [(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 TaskFilter(SerializingObject):
     """
     A set of parameters to filter the task list with.
     """
     """
     A set of parameters to filter the task list with.
     """
@@ -107,7 +449,26 @@ class TaskFilter(object):
 
     def add_filter_param(self, key, value):
         key = key.replace('__', '.')
 
     def add_filter_param(self, key, value):
         key = key.replace('__', '.')
-        self.filter_params.append('{0}:{1}'.format(key, value))
+
+        # Replace the value with empty string, since that is the
+        # convention in TW for empty values
+        attribute_key = key.split('.')[0]
+        value = self._serialize(attribute_key, value)
+
+        # If we are filtering by uuid:, do not use uuid keyword
+        # due to TW-1452 bug
+        if key == 'uuid':
+            self.filter_params.insert(0, value)
+        else:
+            # Surround value with aphostrophes unless it's a empty string
+            value = "'%s'" % value if value else ''
+
+            # We enforce equality match by using 'is' (or 'none') modifier
+            # Without using this syntax, filter fails due to TW-1479
+            modifier = '.is' if value else '.none'
+            key = key + modifier if '.' not in key else key
+
+            self.filter_params.append("{0}:{1}".format(key, value))
 
     def get_filter_params(self):
         return [f for f in self.filter_params if f]
 
     def get_filter_params(self):
         return [f for f in self.filter_params if f]
@@ -231,12 +592,15 @@ class TaskQuerySet(object):
 class TaskWarrior(object):
     def __init__(self, data_location='~/.task', create=True):
         data_location = os.path.expanduser(data_location)
 class TaskWarrior(object):
     def __init__(self, data_location='~/.task', create=True):
         data_location = os.path.expanduser(data_location)
-        if not os.path.exists(data_location):
+        if create and not os.path.exists(data_location):
             os.makedirs(data_location)
         self.config = {
             'data.location': os.path.expanduser(data_location),
             os.makedirs(data_location)
         self.config = {
             'data.location': os.path.expanduser(data_location),
+            'confirmation': 'no',
+            'dependency.confirmation': 'no', # See TW-1483 or taskrc man page
         }
         self.tasks = TaskQuerySet(self)
         }
         self.tasks = TaskQuerySet(self)
+        self.version = self._get_version()
 
     def _get_command_args(self, args, config_override={}):
         command_args = ['task', 'rc:/']
 
     def _get_command_args(self, args, config_override={}):
         command_args = ['task', 'rc:/']
@@ -247,15 +611,26 @@ class TaskWarrior(object):
         command_args.extend(map(str, args))
         return command_args
 
         command_args.extend(map(str, args))
         return command_args
 
+    def _get_version(self):
+        p = subprocess.Popen(
+                ['task', '--version'],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE)
+        stdout, stderr = [x.decode('utf-8') for x in p.communicate()]
+        return stdout.strip('\n')
+
     def execute_command(self, args, config_override={}):
         command_args = self._get_command_args(
             args, config_override=config_override)
         logger.debug(' '.join(command_args))
         p = subprocess.Popen(command_args, stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
     def execute_command(self, args, config_override={}):
         command_args = self._get_command_args(
             args, config_override=config_override)
         logger.debug(' '.join(command_args))
         p = subprocess.Popen(command_args, stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        stdout, stderr = [x.decode('utf-8') for x in p.communicate()]
         if p.returncode:
         if p.returncode:
-            error_msg = stderr.strip().splitlines()[-1]
+            if stderr.strip():
+                error_msg = stderr.strip().splitlines()[-1]
+            else:
+                error_msg = stdout.strip()
             raise TaskWarriorException(error_msg)
         return stdout.strip().split('\n')
 
             raise TaskWarriorException(error_msg)
         return stdout.strip().split('\n')
 
@@ -264,7 +639,13 @@ class TaskWarrior(object):
         tasks = []
         for line in self.execute_command(args):
             if line:
         tasks = []
         for line in self.execute_command(args):
             if line:
-                tasks.append(Task(self, json.loads(line.strip(','))))
+                data = line.strip(',')
+                try:
+                    filtered_task = Task(self)
+                    filtered_task._load_data(json.loads(data))
+                    tasks.append(filtered_task)
+                except ValueError:
+                    raise TaskWarriorException('Invalid JSON: %s' % data)
         return tasks
 
     def merge_with(self, path, push=False):
         return tasks
 
     def merge_with(self, path, push=False):
@@ -274,6 +655,4 @@ class TaskWarrior(object):
         })
 
     def undo(self):
         })
 
     def undo(self):
-        self.execute_command(['undo'], config_override={
-            'confirmation': 'no',
-        })
+        self.execute_command(['undo'])