]> git.madduck.net Git - etc/taskwarrior.git/blobdiff - tasklib/backends.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:

Bump version for 1.2.1 release
[etc/taskwarrior.git] / tasklib / backends.py
index 38b88b1ba042401a908f2116f4ac0cacb1189cd2..38f6c597087dceaf9615a87b197a812a25f75f19 100644 (file)
@@ -1,25 +1,28 @@
 import abc
+import copy
+import datetime
 import json
+import logging
 import os
 import re
+import six
 import subprocess
 
-from tasklib.task import TaskFilter
+from .task import Task, TaskQuerySet, ReadOnlyDictView
+from .filters import TaskWarriorFilter
+from .serializing import local_zone
 
-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')
-VERSION_2_4_1 = six.u('2.4.1')
-VERSION_2_4_2 = six.u('2.4.2')
-VERSION_2_4_3 = six.u('2.4.3')
-VERSION_2_4_4 = six.u('2.4.4')
-VERSION_2_4_5 = six.u('2.4.5')
+DATE_FORMAT_CALC = '%Y-%m-%dT%H:%M:%S'
+
+logger = logging.getLogger(__name__)
 
 
 class Backend(object):
 
-    filter_class = TaskFilter
+    @abc.abstractproperty
+    def filter_class(self):
+        """Returns the TaskFilter class used by this backend"""
+        pass
 
     @abc.abstractmethod
     def filter_tasks(self, filter_obj):
@@ -67,22 +70,47 @@ class Backend(object):
         """Syncs the backend database with the taskd server"""
         pass
 
+    def convert_datetime_string(self, value):
+        """
+        Converts TW syntax datetime string to a localized datetime
+        object. This method is not mandatory.
+        """
+        raise NotImplementedError
+
 
 class TaskWarriorException(Exception):
     pass
 
 
-class TaskWarrior(object):
-    def __init__(self, data_location=None, create=True, taskrc_location='~/.taskrc'):
-        self.taskrc_location = os.path.expanduser(taskrc_location)
+class TaskWarrior(Backend):
+
+    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')
+    VERSION_2_4_1 = six.u('2.4.1')
+    VERSION_2_4_2 = six.u('2.4.2')
+    VERSION_2_4_3 = six.u('2.4.3')
+    VERSION_2_4_4 = six.u('2.4.4')
+    VERSION_2_4_5 = six.u('2.4.5')
+
+    def __init__(self, data_location=None, create=True,
+                 taskrc_location=None, task_command='task',
+                 version_override=None):
+        self.taskrc_location = None
+        if taskrc_location:
+            self.taskrc_location = os.path.expanduser(taskrc_location)
+
+            # If taskrc does not exist, pass / to use defaults and avoid creating
+            # dummy .taskrc file by TaskWarrior
+            if not os.path.exists(self.taskrc_location):
+                self.taskrc_location = '/'
 
-        # If taskrc does not exist, pass / to use defaults and avoid creating
-        # dummy .taskrc file by TaskWarrior
-        if not os.path.exists(self.taskrc_location):
-            self.taskrc_location = '/'
+        self.task_command = task_command
 
-        self.version = self._get_version()
-        self.config = {
+        self._config = None
+        self.version = version_override or self._get_version()
+        self.overrides = {
             'confirmation': 'no',
             'dependency.confirmation': 'no',  # See TW-1483 or taskrc man page
             'recurrence.confirmation': 'no',  # Necessary for modifying R tasks
@@ -92,7 +120,7 @@ class TaskWarrior(object):
 
             # 2.4.3 onwards supports 0 as infite bulk, otherwise set just
             # arbitrary big number which is likely to be large enough
-            'bulk': 0 if self.version >= VERSION_2_4_3 else 100000,
+            'bulk': 0 if self.version >= self.VERSION_2_4_3 else 100000,
         }
 
         # Set data.location override if passed via kwarg
@@ -100,24 +128,30 @@ class TaskWarrior(object):
             data_location = os.path.expanduser(data_location)
             if create and not os.path.exists(data_location):
                 os.makedirs(data_location)
-            self.config['data.location'] = data_location
+            self.overrides['data.location'] = data_location
 
         self.tasks = TaskQuerySet(self)
 
+    def _get_task_command(self):
+        return self.task_command.split()
+
     def _get_command_args(self, args, config_override=None):
-        command_args = ['task', 'rc:{0}'.format(self.taskrc_location)]
-        config = self.config.copy()
-        config.update(config_override or dict())
-        for item in config.items():
+        command_args = self._get_task_command()
+        overrides = self.overrides.copy()
+        overrides.update(config_override or dict())
+        for item in overrides.items():
             command_args.append('rc.{0}={1}'.format(*item))
-        command_args.extend(map(six.text_type, args))
+        command_args.extend([
+            x.decode('utf-8') if isinstance(x, six.binary_type)
+            else six.text_type(x) for x in args
+        ])
         return command_args
 
     def _get_version(self):
         p = subprocess.Popen(
-                ['task', '--version'],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE)
+            self._get_task_command() + ['--version'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE)
         stdout, stderr = [x.decode('utf-8') for x in p.communicate()]
         return stdout.strip('\n')
 
@@ -134,59 +168,132 @@ class TaskWarrior(object):
             if serialized_value is '':
                 escaped_serialized_value = ''
             else:
-                escaped_serialized_value = six.u("'{0}'").format(serialized_value)
+                escaped_serialized_value = six.u("'{0}'").format(
+                    serialized_value)
 
-            format_default = lambda: six.u("{0}:{1}").format(field,
-                                                      escaped_serialized_value)
+            format_default = lambda task: six.u("{0}:{1}").format(
+                field, escaped_serialized_value)
 
-            format_func = getattr(task, 'format_{0}'.format(field),
+            format_func = getattr(self, 'format_{0}'.format(field),
                                   format_default)
 
-            args.append(format_func())
+            args.append(format_func(task))
 
         # If we're modifying saved task, simply pass on all modified fields
         if task.saved:
             for field in task._modified_fields:
                 add_field(field)
+
         # For new tasks, pass all fields that make sense
         else:
             for field in task._data.keys():
+                # We cannot set stuff that's read only (ID, UUID, ..)
                 if field in task.read_only_fields:
                     continue
+                # We do not want to do field deletion for new tasks
+                if task._data[field] is None:
+                    continue
+                # Otherwise we're fine
                 add_field(field)
 
         return args
 
+    def format_depends(self, task):
+        # We need to generate added and removed dependencies list,
+        # since Taskwarrior does not accept redefining dependencies.
 
-    def get_config(self):
-        raw_output = self.execute_command(
-                ['show'],
-                config_override={'verbose': 'nothing'}
+        # 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 = task._original_data.get('depends', set())
+
+        added = task['depends'] - old_dependencies
+        removed = old_dependencies - task['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):
+        # Task version older than 2.4.0 ignores first word of the
+        # task description if description: prefix is used
+        if self.version < self.VERSION_2_4_0:
+            return task._data['description']
+        else:
+            return six.u("description:'{0}'").format(
+                task._data['description'] or '',
             )
 
+    def convert_datetime_string(self, value):
+
+        if self.version >= self.VERSION_2_4_0:
+            # For strings, use 'calc' to evaluate the string to datetime
+            # available since TW 2.4.0
+            args = value.split()
+            result = self.execute_command(['calc'] + args)
+            naive = datetime.datetime.strptime(result[0], DATE_FORMAT_CALC)
+            localized = local_zone.localize(naive)
+        else:
+            raise ValueError(
+                'Provided value could not be converted to '
+                'datetime, its type is not supported: {}'
+                .format(type(value)),
+            )
+
+        return localized
+
+    @property
+    def filter_class(self):
+        return TaskWarriorFilter
+
+    # Public interface
+
+    @property
+    def config(self):
+        # First, check if memoized information is available
+        if self._config:
+            return self._config
+
+        # If not, fetch the config using the 'show' command
+        raw_output = self.execute_command(
+            ['show'],
+            config_override={'verbose': 'nothing'}
+        )
+
         config = dict()
-        config_regex = re.compile(r'^(?P<key>[^\s]+)\s+(?P<value>[^\s].+$)')
+        config_regex = re.compile(r'^(?P<key>[^\s]+)\s+(?P<value>[^\s].*$)')
 
         for line in raw_output:
             match = config_regex.match(line)
             if match:
                 config[match.group('key')] = match.group('value').strip()
 
-        return config
+        # Memoize the config dict
+        self._config = ReadOnlyDictView(config)
+
+        return self._config
 
     def execute_command(self, args, config_override=None, allow_failure=True,
                         return_all=False):
         command_args = self._get_command_args(
             args, config_override=config_override)
-        logger.debug(' '.join(command_args))
+        logger.debug(u' '.join(command_args))
+
+        env = os.environ.copy()
+        if self.taskrc_location:
+            env['TASKRC'] = self.taskrc_location
         p = subprocess.Popen(command_args, stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
+                             stderr=subprocess.PIPE, env=env)
         stdout, stderr = [x.decode('utf-8') for x in p.communicate()]
         if p.returncode and allow_failure:
             if stderr.strip():
                 error_msg = stderr.strip()
             else:
                 error_msg = stdout.strip()
+            error_msg += u'\nCommand used: ' + u' '.join(command_args)
             raise TaskWarriorException(error_msg)
 
         # Return all whole triplet only if explicitly asked for
@@ -202,7 +309,7 @@ class TaskWarrior(object):
         # of recurrent tasks.
 
         # Only necessary for TW up to 2.4.1, fixed in 2.4.2.
-        if self.version < VERSION_2_4_2:
+        if self.version < self.VERSION_2_4_2:
             self.execute_command(['next'], allow_failure=False)
 
     def merge_with(self, path, push=False):
@@ -218,7 +325,7 @@ class TaskWarrior(object):
 
     def filter_tasks(self, filter_obj):
         self.enforce_recurrence()
-        args = ['export', '--'] + filter_obj.get_filter_params()
+        args = ['export'] + filter_obj.get_filter_params()
         tasks = []
         for line in self.execute_command(args):
             if line:
@@ -243,10 +350,14 @@ class TaskWarrior(object):
             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))
+            # Should not happen.
+            # Expected output: Created task 1.
+            #                  Created task 1 (recurrence template).
+            if len(id_lines) != 1 or len(id_lines[0].split(' ')) not in (3, 5):
+                raise TaskWarriorException(
+                    'Unexpected output when creating '
+                    'task: %s' % '\n'.join(id_lines),
+                )
 
             # Circumvent the ID storage, since ID is considered read-only
             identifier = id_lines[0].split(' ')[2].rstrip('.')
@@ -273,7 +384,7 @@ class TaskWarrior(object):
 
     def complete_task(self, task):
         # Older versions of TW do not stop active task at completion
-        if self.version < VERSION_2_4_0 and task.active:
+        if self.version < self.VERSION_2_4_0 and task.active:
             task.stop()
 
         self.execute_command([task['uuid'], 'done'])
@@ -299,7 +410,7 @@ class TaskWarrior(object):
         # For older TW versions attempt to uniquely locate the task
         # using the data we have if it has been just saved.
         # This can happen when adding a completed task on older TW versions.
-        if (not valid(output) and self.version < VERSION_2_4_5
+        if (not valid(output) and self.version < self.VERSION_2_4_5
                 and after_save):
 
             # Make a copy, removing ID and UUID. It's most likely invalid
@@ -312,15 +423,15 @@ class TaskWarrior(object):
             for key, value in data.items():
                 taskfilter.add_filter_param(key, value)
 
-            output = self.execute_command(['export', '--'] +
-                taskfilter.get_filter_params())
+            output = self.execute_command(['export'] +
+                                          taskfilter.get_filter_params())
 
         # If more than 1 task has been matched still, raise an exception
         if not valid(output):
             raise TaskWarriorException(
-                "Unique identifiers {0} with description: {1} matches "
-                "multiple tasks: {2}".format(
-                task['uuid'] or task['id'], task['description'], output)
+                'Unique identifiers {0} with description: {1} matches '
+                'multiple tasks: {2}'.format(
+                    task['uuid'] or task['id'], task['description'], output)
             )
 
         return json.loads(output[0])