]> 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: Add LazyUUIDTaskSet wrapper
[etc/taskwarrior.git] / tasklib / task.py
index 4377f1fb8f1737d730a7cb782c1a2d5f74ba3cd6..6ebee4cc6b7442ceb2b62a3126324fbcc91e30fb 100644 (file)
@@ -1,37 +1,84 @@
 from __future__ import print_function
 import copy
-import datetime
+import importlib
 import json
 import logging
 import os
 import six
-import subprocess
+import sys
+
+from .serializing import SerializingObject
 
 DATE_FORMAT = '%Y%m%dT%H%M%SZ'
 REPR_OUTPUT_SIZE = 10
 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__)
 
 
-class TaskWarriorException(Exception):
-    pass
+class ReadOnlyDictView(object):
+    """
+    Provides simplified read-only view upon dict object.
+    """
+
+    def __init__(self, viewed_dict):
+        self.viewed_dict = viewed_dict
 
+    def __getitem__(self, key):
+        return copy.deepcopy(self.viewed_dict.__getitem__(key))
+
+    def __contains__(self, k):
+        return self.viewed_dict.__contains__(k)
+
+    def __iter__(self):
+        for value in self.viewed_dict:
+            yield copy.deepcopy(value)
+
+    def __len__(self):
+        return len(self.viewed_dict)
 
-class TaskResource(object):
+    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))
+
+    def items(self):
+        return [copy.deepcopy(v) for v in self.viewed_dict.items()]
+
+    def values(self):
+        return [copy.deepcopy(v) for v in self.viewed_dict.values()]
+
+
+class TaskResource(SerializingObject):
     read_only_fields = []
 
     def _load_data(self, data):
-        self._data = 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 = data.copy()
+        # are not propagated.
+        self._original_data = copy.deepcopy(self._data)
+
+    def _update_data(self, data, update_original=False, remove_missing=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()))
+
+        # In certain situations, we want to treat missing keys as removals
+        if remove_missing:
+            for key in set(self._data.keys()) - set(data.keys()):
+                self._data[key] = None
+
+        if update_original:
+            self._original_data = copy.deepcopy(self._data)
 
     def __getitem__(self, key):
         # This is a workaround to make TaskResource non-iterable
@@ -42,16 +89,18 @@ class TaskResource(object):
         except ValueError:
             pass
 
-        hydrate_func = getattr(self, 'deserialize_{0}'.format(key),
-                               lambda x: x)
-        return hydrate_func(self._data.get(key))
+        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)
-        dehydrate_func = getattr(self, 'serialize_{0}'.format(key),
-                                 lambda x: x)
-        self._data[key] = dehydrate_func(value)
+
+        # Normalize the user input before saving it
+        value = self._normalize(key, value)
+        self._data[key] = value
 
     def __str__(self):
         s = six.text_type(self.__unicode__())
@@ -62,19 +111,48 @@ class TaskResource(object):
     def __repr__(self):
         return str(self)
 
+    def export_data(self):
+        """
+        Exports current data contained in the Task as JSON
+        """
+
+        # We need to remove spaces for TW-1504, use custom separators
+        data_tuples = ((key, self._serialize(key, value))
+                       for key, value in six.iteritems(self._data))
+
+        # Empty string denotes empty serialized value, we do not want
+        # 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=(',', ':'))
+
+    @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 modified(self):
+        return bool(list(self._modified_fields))
+
 
 class TaskAnnotation(TaskResource):
     read_only_fields = ['entry', 'description']
 
-    def __init__(self, task, data={}):
+    def __init__(self, task, data=None):
         self.task = task
-        self._load_data(data)
-
-    def deserialize_entry(self, data):
-        return datetime.datetime.strptime(data, DATE_FORMAT) if data else None
-
-    def serialize_entry(self, date):
-        return date.strftime(DATE_FORMAT) if date else ''
+        self._load_data(data or dict())
+        super(TaskAnnotation, self).__init__(task.backend)
 
     def remove(self):
         self.task.remove_annotation(self)
@@ -82,11 +160,107 @@ class TaskAnnotation(TaskResource):
     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 LazyUUIDTask(object):
+    """
+    A lazy wrapper around Task object, referenced by UUID.
+
+    - Supports comparison with LazyUUIDTask or Task objects (equality by UUIDs)
+    - If any attribute other than 'uuid' requested, a lookup in the
+      backend will be performed and this object will be replaced by a proper
+      Task object.
+    """
+
+    def __init__(self, tw, uuid):
+        self._tw = tw
+        self._uuid = uuid
+
+    def __getitem__(self, key):
+        # LazyUUIDTask does not provide anything else other than 'uuid'
+        if key is 'uuid':
+            return self._uuid
+        else:
+            self.replace()
+            return self[key]
+
+    def __getattr__(self, name):
+        # Getattr is called only if the attribute could not be found using
+        # normal means
+        self.replace()
+        return self.name
+
+    def __eq__(self, other):
+        if other['uuid']:
+            # For saved Tasks, just define equality by equality of uuids
+            return self['uuid'] == other['uuid']
+
+    def __hash__(self):
+        return self['uuid'].__hash__()
+
+    def replace(self):
+        """
+        Performs conversion to the regular Task object, referenced by the
+        stored UUID.
+        """
+
+        replacement = self._tw.tasks.get(uuid=self._uuid)
+        self.__class__ = replacement.__class__
+        self.__dict__ = replacement.__dict__
+
+
+class LazyUUIDTaskSet(object):
+    """
+    A lazy wrapper around TaskQuerySet object, for tasks referenced by UUID.
+
+    - Supports 'in' operator with LazyUUIDTask or Task objects
+    - If iteration over the objects in the LazyUUIDTaskSet is requested, the
+      LazyUUIDTaskSet will be converted to QuerySet and evaluated
+    """
+
+    def __init__(self, tw, uuids):
+        self._tw = tw
+        self._uuids = set(uuids)
+
+    def __getattr__(self, name):
+        # Getattr is called only if the attribute could not be found using
+        # normal means
+        self.replace()
+        return self.name
+
+    def __eq__(self, other):
+        return set(t['uuid'] for t in other) == self._uuids
+
+    def __contains__(self, task):
+        return task['uuid'] in self._uuids
+
+    def __len__(self):
+        return len(self._uuids)
+
+    def __iter__(self):
+        self.replace()
+        for task in self:
+            yield task
+
+    def replace(self):
+        """
+        Performs conversion to the regular TaskQuerySet object, referenced by
+        the stored UUIDs.
+        """
+
+        replacement = self._tw.tasks.filter(' '.join(self._uuids))
+        self.__class__ = replacement.__class__
+        self.__dict__ = replacement.__dict__
+
+
 class Task(TaskResource):
-    read_only_fields = ['id', 'entry', 'urgency', 'uuid']
+    read_only_fields = ['id', 'entry', 'urgency', 'uuid', 'modified']
 
     class DoesNotExist(Exception):
         pass
@@ -103,6 +277,18 @@ class Task(TaskResource):
         """
         pass
 
+    class ActiveTask(Exception):
+        """
+        Raised when the operation cannot be performed on the active task.
+        """
+        pass
+
+    class InactiveTask(Exception):
+        """
+        Raised when the operation cannot be performed on an inactive task.
+        """
+        pass
+
     class NotSaved(Exception):
         """
         Raised when the operation cannot be performed on the task, because
@@ -110,13 +296,66 @@ class Task(TaskResource):
         """
         pass
 
-    def __init__(self, warrior, data={}, **kwargs):
-        self.warrior = warrior
+    @classmethod
+    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
+        original state of the Task object, and second line as its new,
+        modified value. This is consistent with the TaskWarrior's hook
+        system.
+
+        Object created by this method should not be saved, deleted
+        or refreshed, as t could create a infinite loop. For this
+        reason, TaskWarrior instance is set to None.
+
+        Input_file argument can be used to specify the input file,
+        but defaults to sys.stdin.
+        """
+
+        # Detect the hook type if not given directly
+        name = os.path.basename(sys.argv[0])
+        modify = name.startswith('on-modify') if modify is None else modify
+
+        # Create the TaskWarrior instance if none passed
+        if backend is None:
+            backends = importlib.import_module('tasklib.backends')
+            hook_parent_dir = os.path.dirname(os.path.dirname(sys.argv[0]))
+            backend = backends.TaskWarrior(data_location=hook_parent_dir)
+
+        # TaskWarrior instance is set to None
+        task = cls(backend)
+
+        # Load the data from the input
+        task._load_data(json.loads(input_file.readline().strip()))
+
+        # If this is a on-modify event, we are provided with additional
+        # line of input, which provides updated data
+        if modify:
+            task._update_data(json.loads(input_file.readline().strip()),
+                              remove_missing=True)
 
-        # We keep data for backwards compatibility
-        kwargs.update(data)
+        return task
 
-        self._load_data(kwargs)
+    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():
+            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._data = dict((key, self._normalize(key, value))
+                          for (key, value) in six.iteritems(kwargs))
+        self._original_data = copy.deepcopy(self._data)
+
+        # Provide read only access to the original data
+        self.original = ReadOnlyDictView(self._original_data)
 
     def __unicode__(self):
         return self['description']
@@ -129,7 +368,6 @@ class Task(TaskResource):
             # 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
@@ -138,12 +376,6 @@ class Task(TaskResource):
             # If the tasks are not saved, return hash of instance id
             return id(self).__hash__()
 
-    @property
-    def _modified_fields(self):
-        for key in self._data.keys():
-            if self._data.get(key) != self._original_data.get(key):
-                yield key
-
     @property
     def completed(self):
         return self['status'] == six.text_type('completed')
@@ -160,81 +392,71 @@ class Task(TaskResource):
     def pending(self):
         return self['status'] == six.text_type('pending')
 
+    @property
+    def active(self):
+        return self['start'] is not None
+
     @property
     def saved(self):
         return self['uuid'] is not None or self['id'] is not None
 
-    def serialize_due(self, date):
-        return date.strftime(DATE_FORMAT)
-
-    def deserialize_due(self, date_str):
-        if not date_str:
-            return None
-        return datetime.datetime.strptime(date_str, DATE_FORMAT)
-
     def serialize_depends(self, cur_dependencies):
         # Check that all the tasks are saved
-        for task in cur_dependencies:
+        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)
 
-        # Return the list of uuids
-        return ','.join(task['uuid'] for task in cur_dependencies)
+        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")
 
-    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)
+        # Refresh the status, and raise exception if the task is deleted
+        self.refresh(only_fields=['status'])
 
-    def format_depends(self):
-        # We need to generate added and removed dependencies list,
-        # since Taskwarrior does not accept redefining dependencies.
+        if self.deleted:
+            raise Task.DeletedTask("Task was already deleted")
 
-        # 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
+        self.backend.delete_task(self)
 
-        old_dependencies_raw = self._original_data.get('depends','')
-        old_dependencies = self.deserialize_depends(old_dependencies_raw)
+        # Refresh the status again, so that we have updated info stored
+        self.refresh(only_fields=['status', 'start', 'end'])
 
-        added = self['depends'] - old_dependencies
-        removed = old_dependencies - self['depends']
+    def start(self):
+        if not self.saved:
+            raise Task.NotSaved("Task needs to be saved before it can be started")
 
-        # Removed dependencies need to be prefixed with '-'
-        return ','.join(
-                [t['uuid'] for t in added] +
-                ['-' + t['uuid'] for t in removed]
-            )
+        # Refresh, and raise exception if task is already completed/deleted
+        self.refresh(only_fields=['status'])
 
-    def deserialize_annotations(self, data):
-        return [TaskAnnotation(self, d) for d in data] if data else []
+        if self.completed:
+            raise Task.CompletedTask("Cannot start a completed task")
+        elif self.deleted:
+            raise Task.DeletedTask("Deleted task cannot be started")
+        elif self.active:
+            raise Task.ActiveTask("Task is already active")
 
-    def deserialize_tags(self, tags):
-        if isinstance(tags, basestring):
-            return tags.split(',') if tags else []
-        return tags
+        self.backend.start_task(self)
 
-    def serialize_tags(self, tags):
-        return ','.join(tags) if tags else ''
+        # Refresh the status again, so that we have updated info stored
+        self.refresh(only_fields=['status', 'start'])
 
-    def delete(self):
+    def stop(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 stopped")
 
-        # Refresh the status, and raise exception if the task is deleted
+        # Refresh, and raise exception if task is already completed/deleted
         self.refresh(only_fields=['status'])
 
-        if self.deleted:
-            raise Task.DeletedTask("Task was already deleted")
+        if not self.active:
+            raise Task.InactiveTask("Cannot stop an inactive task")
 
-        self.warrior.execute_command([self['uuid'], 'delete'], config_override={
-            'confirmation': 'no',
-        })
+        self.backend.stop_task(self)
 
         # Refresh the status again, so that we have updated info stored
-        self.refresh(only_fields=['status'])
-
+        self.refresh(only_fields=['status', 'start'])
 
     def done(self):
         if not self.saved:
@@ -248,131 +470,48 @@ class Task(TaskResource):
         elif self.deleted:
             raise Task.DeletedTask("Deleted task cannot be completed")
 
-        self.warrior.execute_command([self['uuid'], 'done'])
+        self.backend.complete_task(self)
 
         # Refresh the status again, so that we have updated info stored
-        self.refresh(only_fields=['status'])
+        self.refresh(only_fields=['status', 'start', 'end'])
 
     def save(self):
-        args = [self['uuid'], 'modify'] if self.saved else ['add']
-        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))
+        if self.saved and not self.modified:
+            return
 
-            # Circumvent the ID storage, since ID is considered read-only
-            self._data['id'] = int(id_lines[0].split(' ')[2].rstrip('.'))
-
-        self.refresh()
+        # All the actual work is done by the backend
+        self.backend.save_task(self)
 
     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.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 add annotation")
+            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.refresh(only_fields=['annotations'])
-
-    def _get_modified_fields_as_args(self):
-        args = []
-
-        def add_field(field):
-            # 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 and field == 'description':
-                args.append(self._data[field])
-            elif field == 'depends':
-                args.append('{0}:{1}'.format(field, self.format_depends()))
-            else:
-                # Use empty string to substitute for None value
-                args.append('{0}:{1}'.format(field, self._data[field] or ''))
-
-        # 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
+        self.backend.denotate_task(self, annotation)
+        self.refresh(only_fields=['annotations'])
 
-    def refresh(self, only_fields=[]):
+    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")
 
-        # 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])
+        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])
-            self._data.update(to_update)
-            self._original_data.update(to_update)
-        else:
-            self._data = new_data
-            # We need to create a clone for original_data though
-            # Shallow copy is alright, since data dict uses only
-            # primitive data types
-            self._original_data = new_data.copy()
-
-
-class TaskFilter(object):
-    """
-    A set of parameters to filter the task list with.
-    """
-
-    def __init__(self, filter_params=[]):
-        self.filter_params = filter_params
-
-    def add_filter(self, filter_str):
-        self.filter_params.append(filter_str)
-
-    def add_filter_param(self, key, value):
-        key = key.replace('__', '.')
-
-        # Replace the value with empty string, since that is the
-        # convention in TW for empty values
-        value = value if value is not None else ''
-
-        # 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)
+            self._update_data(to_update, update_original=True)
         else:
-            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 clone(self):
-        c = self.__class__()
-        c.filter_params = list(self.filter_params)
-        return c
+            self._load_data(new_data)
 
 
 class TaskQuerySet(object):
@@ -380,16 +519,16 @@ 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 TaskFilter()
+        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
@@ -434,7 +573,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
 
@@ -442,7 +581,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):
         """
@@ -483,70 +622,3 @@ class TaskQuerySet(object):
         raise ValueError(
             'get() returned more than one Task -- it returned {0}! '
             'Lookup parameters were {1}'.format(num, kwargs))
-
-
-class TaskWarrior(object):
-    def __init__(self, data_location='~/.task', create=True):
-        data_location = os.path.expanduser(data_location)
-        if create and not os.path.exists(data_location):
-            os.makedirs(data_location)
-        self.config = {
-            'data.location': os.path.expanduser(data_location),
-        }
-        self.tasks = TaskQuerySet(self)
-        self.version = self._get_version()
-
-    def _get_command_args(self, args, config_override={}):
-        command_args = ['task', 'rc:/']
-        config = self.config.copy()
-        config.update(config_override)
-        for item in config.items():
-            command_args.append('rc.{0}={1}'.format(*item))
-        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)
-        stdout, stderr = [x.decode('utf-8') for x in p.communicate()]
-        if p.returncode:
-            if stderr.strip():
-                error_msg = stderr.strip().splitlines()[-1]
-            else:
-                error_msg = stdout.strip()
-            raise TaskWarriorException(error_msg)
-        return stdout.strip().split('\n')
-
-    def filter_tasks(self, filter_obj):
-        args = ['export', '--'] + filter_obj.get_filter_params()
-        tasks = []
-        for line in self.execute_command(args):
-            if line:
-                data = line.strip(',')
-                try:
-                    tasks.append(Task(self, json.loads(data)))
-                except ValueError:
-                    raise TaskWarriorException('Invalid JSON: %s' % data)
-        return tasks
-
-    def merge_with(self, path, push=False):
-        path = path.rstrip('/') + '/'
-        self.execute_command(['merge', path], config_override={
-            'merge.autopush': 'yes' if push else 'no',
-        })
-
-    def undo(self):
-        self.execute_command(['undo'], config_override={
-            'confirmation': 'no',
-        })