X-Git-Url: https://git.madduck.net/etc/taskwarrior.git/blobdiff_plain/8f39904e76a1462d81fbe80e07a82bba11035cd8..1de91d347157b73cd240df7fa950b99ec221b304:/tasklib/lazy.py

diff --git a/tasklib/lazy.py b/tasklib/lazy.py
index 0bd9332..7d8e0de 100644
--- a/tasklib/lazy.py
+++ b/tasklib/lazy.py
@@ -29,16 +29,40 @@ class LazyUUIDTask(object):
         # Getattr is called only if the attribute could not be found using
         # normal means
         self.replace()
-        return self.name
+        return getattr(self, name)
 
     def __eq__(self, other):
-        if other['uuid']:
+        if other and 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 __repr__(self):
+        return 'LazyUUIDTask: {0}'.format(self._uuid)
+
+    def __copy__(self):
+        return LazyUUIDTask(self._tw, self._uuid)
+
+    def __deepcopy__(self, memo):
+        return LazyUUIDTask(self._tw, self._uuid)
+
+    @property
+    def saved(self):
+        """
+        Implementation of the 'saved' property. Always returns True.
+        """
+        return True
+
+    @property
+    def _modified_fields(self):
+        return set()
+
+    @property
+    def modified(self):
+        return False
+
     def replace(self):
         """
         Performs conversion to the regular Task object, referenced by the
@@ -66,12 +90,24 @@ class LazyUUIDTaskSet(object):
     def __getattr__(self, name):
         # Getattr is called only if the attribute could not be found using
         # normal means
-        self.replace()
-        return self.name
+
+        if name.startswith('__'):
+            # If some internal method was being search, do not convert
+            # to TaskQuerySet just because of that
+            raise AttributeError
+        else:
+            self.replace()
+            return getattr(self, name)
+
+    def __repr__(self):
+        return 'LazyUUIDTaskSet([{0}])'.format(', '.join(self._uuids))
 
     def __eq__(self, other):
         return set(t['uuid'] for t in other) == self._uuids
 
+    def __ne__(self, other):
+        return not (self == other)
+
     def __contains__(self, task):
         return task['uuid'] in self._uuids
 
@@ -79,9 +115,111 @@ class LazyUUIDTaskSet(object):
         return len(self._uuids)
 
     def __iter__(self):
-        self.replace()
-        for task in self:
-            yield task
+        for uuid in self._uuids:
+            yield LazyUUIDTask(self._tw, uuid)
+
+    def __sub__(self, other):
+        return self.difference(other)
+
+    def __isub__(self, other):
+        return self.difference_update(other)
+
+    def __rsub__(self, other):
+        return LazyUUIDTaskSet(
+            self._tw,
+            set(t['uuid'] for t in other) - self._uuids,
+        )
+
+    def __or__(self, other):
+        return self.union(other)
+
+    def __ior__(self, other):
+        return self.update(other)
+
+    def __ror__(self, other):
+        return self.union(other)
+
+    def __xor__(self, other):
+        return self.symmetric_difference(other)
+
+    def __ixor__(self, other):
+        return self.symmetric_difference_update(other)
+
+    def __rxor__(self, other):
+        return self.symmetric_difference(other)
+
+    def __and__(self, other):
+        return self.intersection(other)
+
+    def __iand__(self, other):
+        return self.intersection_update(other)
+
+    def __rand__(self, other):
+        return self.intersection(other)
+
+    def __le__(self, other):
+        return self.issubset(other)
+
+    def __ge__(self, other):
+        return self.issuperset(other)
+
+    def issubset(self, other):
+        return all([task in other for task in self])
+
+    def issuperset(self, other):
+        return all([task in self for task in other])
+
+    def union(self, other):
+        return LazyUUIDTaskSet(
+            self._tw,
+            self._uuids | set(t['uuid'] for t in other),
+        )
+
+    def intersection(self, other):
+        return LazyUUIDTaskSet(
+            self._tw,
+            self._uuids & set(t['uuid'] for t in other),
+        )
+
+    def difference(self, other):
+        return LazyUUIDTaskSet(
+            self._tw,
+            self._uuids - set(t['uuid'] for t in other),
+        )
+
+    def symmetric_difference(self, other):
+        return LazyUUIDTaskSet(
+            self._tw,
+            self._uuids ^ set(t['uuid'] for t in other),
+        )
+
+    def update(self, other):
+        self._uuids |= set(t['uuid'] for t in other)
+        return self
+
+    def intersection_update(self, other):
+        self._uuids &= set(t['uuid'] for t in other)
+        return self
+
+    def difference_update(self, other):
+        self._uuids -= set(t['uuid'] for t in other)
+        return self
+
+    def symmetric_difference_update(self, other):
+        self._uuids ^= set(t['uuid'] for t in other)
+        return self
+
+    def add(self, task):
+        self._uuids.add(task['uuid'])
+
+    def remove(self, task):
+        self._uuids.remove(task['uuid'])
+
+    def pop(self):
+        return self._uuids.pop()
+
+    def clear(self):
+        self._uuids.clear()
 
     def replace(self):
         """