add __ne__ methods for python2 compatibility

[etc/taskwarrior.git] / tasklib / task.py

diff --git a/tasklib/task.py b/tasklib/task.py
index 18acfe58995203db2efbdf80c397055821046274..57b73384e91ce9cb2ea63c32545266f0b8aff1e4 100644 (file)
--- a/tasklib/task.py
+++ b/tasklib/task.py
@@ -1,6 +1,5 @@
 from __future__ import print_function
 import copy
-import datetime
 import importlib
 import json
 import logging
@@ -39,6 +38,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 +80,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 +124,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 +152,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 +165,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 +209,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,13 +230,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:
-            backends = importlib.import_module('.backends')
+        if backend is None:
+            backends = importlib.import_module('tasklib.backends')
             hook_parent_dir = os.path.dirname(os.path.dirname(sys.argv[0]))
-            warrior = backends.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()))
@@ -243,8 +249,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():
@@ -274,6 +280,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']:
@@ -420,21 +428,22 @@ class Task(TaskResource):
         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
@@ -479,7 +488,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
 
@@ -487,7 +496,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):
         """