]>
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:
return ','.join(tags) if tags else ''
def deserialize_tags(self, tags):
return ','.join(tags) if tags else ''
def deserialize_tags(self, tags):
- if isinstance(tags, basestring ):
+ if isinstance(tags, six.string_types ):
return tags.split(',') if tags else []
return tags.split(',') if tags else []
def serialize_depends(self, cur_dependencies):
# Return the list of uuids
def serialize_depends(self, cur_dependencies):
# Return the list of uuids
read_only_fields = []
def _load_data(self, data):
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
# We need to use a copy for original data, so that changes
- # are not propagated. Shallow copy is alright, since data dict uses only
- # primitive data types
- self._original_data = data.copy()
+ # are not propagated.
+ self._original_data = copy.deepcopy(self._data)
def _update_data(self, data, update_original=False):
"""
def _update_data(self, data, update_original=False):
"""
updates should already be serialized. If update_original is True, the
original_data dict is updated as well.
"""
updates should already be serialized. If update_original is True, the
original_data dict is updated as well.
"""
-
- self._data.update(data )
+ self._data.update(dict((key, self._deserialize(key, value))
+ for key, value in data.items()) )
- self._original_data.update(data)
+ self._original_data = copy.deepcopy(self._data)
+
def __getitem__(self, key):
# This is a workaround to make TaskResource non-iterable
def __getitem__(self, key):
# This is a workaround to make TaskResource non-iterable
- return self._deserialize(key, 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)
def __setitem__(self, key, value):
if key in self.read_only_fields:
raise RuntimeError('Field \'%s\' is read-only' % key)
- self._data[key] = self._serialize(key, value)
+ self._data[key] = value
def __str__(self):
s = six.text_type(self.__unicode__())
def __str__(self):
s = six.text_type(self.__unicode__())
def __unicode__(self):
return self['description']
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
+
def _modified_fields(self):
writable_fields = set(self._data.keys()) - set(self.read_only_fields)
for key in writable_fields:
def _modified_fields(self):
writable_fields = set(self._data.keys()) - set(self.read_only_fields)
for key in writable_fields:
- if self._data.get(key) != self._original_data.get(key):
+ 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:
+ @property
+ def _is_modified(self):
+ return bool(list(self._modified_fields))
+
@property
def completed(self):
return self['status'] == six.text_type('completed')
@property
def completed(self):
return self['status'] == six.text_type('completed')
# to keep a list of all depedencies in the _data dictionary,
# not just currently added/removed ones
# to keep a list of all depedencies in the _data dictionary,
# not just currently added/removed ones
- old_dependencies_raw = self._original_data.get('depends','')
- old_dependencies = self.deserialize_depends(old_dependencies_raw)
+ old_dependencies = self._original_data.get('depends', set())
added = self['depends'] - old_dependencies
removed = old_dependencies - self['depends']
added = self['depends'] - old_dependencies
removed = old_dependencies - self['depends']
self.refresh(only_fields=['status'])
def save(self):
self.refresh(only_fields=['status'])
def save(self):
+ 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())
output = self.warrior.execute_command(args)
args = [self['uuid'], 'modify'] if self.saved else ['add']
args.extend(self._get_modified_fields_as_args())
output = self.warrior.execute_command(args)
def add_field(field):
# Add the output of format_field method to args list (defaults to
# field:value)
def add_field(field):
# Add the output of format_field method to args list (defaults to
# field:value)
- format_default = lambda k: "{0}:'{1}'".format(k, self._data[k] or '')
+ 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_func = getattr(self, 'format_{0}'.format(field),
- lambda: format_default(field) )
args.append(format_func())
# If we're modifying saved task, simply pass on all modified fields
args.append(format_func())
# If we're modifying saved task, simply pass on all modified fields
projects / etc / taskwarrior.git / blobdiff