Added a slightly tweaked version of timedelta, in order to support handling of TimedeltaFields.

 - Legacy-Id: 9109

Author: levkowetz

timedelta/VERSION

@@ -0,0 +1 @@
+0.7.3

timedelta/__init__.py

@@ -0,0 +1,19 @@
+import os
+
+__version__ = open(os.path.join(os.path.dirname(__file__), "VERSION")).read().strip()
+
+try:
+    from django.core.exceptions import ImproperlyConfigured
+except ImportError:
+    ImproperlyConfigured = ImportError
+
+try:
+    from .fields import TimedeltaField
+    from .helpers import (
+        divide, multiply, modulo, 
+        parse, nice_repr, 
+        percentage, decimal_percentage,
+        total_seconds
+    )
+except (ImportError, ImproperlyConfigured):
+    pass

timedelta/fields.py

@@ -0,0 +1,120 @@
+from django.db import models
+from django.core.exceptions import ValidationError
+from django.utils import six
+
+from collections import defaultdict
+import datetime
+import six
+    
+from .helpers import parse
+from .forms import TimedeltaFormField
+
+# TODO: Figure out why django admin thinks fields of this type have changed every time an object is saved.
+
+# Define the different column types that different databases can use.
+COLUMN_TYPES = defaultdict(lambda:"char(20)")
+COLUMN_TYPES["django.db.backends.postgresql_psycopg2"] = "interval"
+COLUMN_TYPES["django.contrib.gis.db.backends.postgis"] = "interval"
+
+class TimedeltaField(six.with_metaclass(models.SubfieldBase, models.Field)):
+    """
+    Store a datetime.timedelta as an INTERVAL in postgres, or a
+    CHAR(20) in other database backends.
+    """
+    _south_introspects = True
+
+    description = "A datetime.timedelta object"
+
+    def __init__(self, *args, **kwargs):
+        self._min_value = kwargs.pop('min_value', None)
+
+        if isinstance(self._min_value, (int, float)):
+            self._min_value = datetime.timedelta(seconds=self._min_value)
+
+        self._max_value = kwargs.pop('max_value', None)
+
+        if isinstance(self._max_value, (int, float)):
+            self._max_value = datetime.timedelta(seconds=self._max_value)
+
+        super(TimedeltaField, self).__init__(*args, **kwargs)
+
+    def to_python(self, value):
+        if (value is None) or isinstance(value, datetime.timedelta):
+            return value
+        if isinstance(value, (int, float)):
+            return datetime.timedelta(seconds=value)
+        if isinstance(value, six.string_types) and value.replace('.','0').isdigit():
+            return datetime.timedelta(seconds=float(value))
+        if value == "":
+            if self.null:
+                return None
+            else:
+                return datetime.timedelta(0)
+        return parse(value)
+
+    def get_prep_value(self, value):
+        if self.null and value == "":
+            return None
+        if (value is None) or isinstance(value, six.string_types):
+            return value
+        return str(value).replace(',', '')
+
+    def get_db_prep_value(self, value, connection=None, prepared=None):
+        return self.get_prep_value(value)
+
+    def formfield(self, *args, **kwargs):
+        defaults = {'form_class':TimedeltaFormField}
+        defaults.update(kwargs)
+        return super(TimedeltaField, self).formfield(*args, **defaults)
+
+    def validate(self, value, model_instance):
+        super(TimedeltaField, self).validate(value, model_instance)
+        if self._min_value is not None:
+            if self._min_value > value:
+                raise ValidationError('Less than minimum allowed value')
+        if self._max_value is not None:
+            if self._max_value < value:
+                raise ValidationError('More than maximum allowed value')
+
+    def value_to_string(self, obj):
+        value = self._get_val_from_obj(obj)
+        return unicode(value)
+
+    def get_default(self):
+        """
+        Needed to rewrite this, as the parent class turns this value into a
+        unicode string. That sux pretty deep.
+        """
+        if self.has_default():
+            if callable(self.default):
+                return self.default()
+            return self.get_prep_value(self.default)
+        if not self.empty_strings_allowed or (self.null):
+            return None
+        return ""
+
+    def db_type(self, connection):
+        return COLUMN_TYPES[connection.settings_dict['ENGINE']]
+
+    def deconstruct(self):
+        """
+        Break down this field into arguments that can be used to reproduce it
+        with Django migrations.
+
+        The thing to to note here is that currently the migration file writer
+        can't serialize timedelta objects so we convert them to a float
+        representation (in seconds) that we can later interpret as a timedelta.
+        """
+
+        name, path, args, kwargs = super(TimedeltaField, self).deconstruct()
+
+        if isinstance(self._min_value, datetime.timedelta):
+            kwargs['min_value'] = self._min_value.total_seconds()
+
+        if isinstance(self._max_value, datetime.timedelta):
+            kwargs['max_value'] = self._max_value.total_seconds()
+
+        if isinstance(kwargs.get('default'), datetime.timedelta):
+            kwargs['default'] = kwargs['default'].total_seconds()
+
+        return name, path, args, kwargs

timedelta/forms.py

@@ -0,0 +1,99 @@
+from django import forms
+from django.utils.translation import ugettext_lazy as _
+from django.utils import six
+
+import datetime
+from collections import defaultdict
+
+from .widgets import TimedeltaWidget
+from .helpers import parse
+
+class TimedeltaFormField(forms.Field):
+    
+    default_error_messages = {
+        'invalid':_('Enter a valid time span: e.g. "3 days, 4 hours, 2 minutes"')
+    }
+    
+    def __init__(self, *args, **kwargs):
+        defaults = {'widget':TimedeltaWidget}
+        defaults.update(kwargs)
+        super(TimedeltaFormField, self).__init__(*args, **defaults)
+        
+    def clean(self, value):
+        """
+        This doesn't really need to be here: it should be tested in
+        parse()...
+        
+        >>> t = TimedeltaFormField()
+        >>> t.clean('1 day')
+        datetime.timedelta(1)
+        >>> t.clean('1 day, 0:00:00')
+        datetime.timedelta(1)
+        >>> t.clean('1 day, 8:42:42.342')
+        datetime.timedelta(1, 31362, 342000)
+        >>> t.clean('3 days, 8:42:42.342161')
+        datetime.timedelta(3, 31362, 342161)
+        >>> try:
+        ...  t.clean('3 days, 8:42:42.3.42161')
+        ... except forms.ValidationError as arg:
+        ...  six.print_(arg.messages[0])
+        Enter a valid time span: e.g. "3 days, 4 hours, 2 minutes"
+        >>> t.clean('5 day, 8:42:42')
+        datetime.timedelta(5, 31362)
+        >>> t.clean('1 days')
+        datetime.timedelta(1)
+        >>> t.clean('1 second')
+        datetime.timedelta(0, 1)
+        >>> t.clean('1 sec')
+        datetime.timedelta(0, 1)
+        >>> t.clean('10 seconds')
+        datetime.timedelta(0, 10)
+        >>> t.clean('30 seconds')
+        datetime.timedelta(0, 30)
+        >>> t.clean('1 minute, 30 seconds')
+        datetime.timedelta(0, 90)
+        >>> t.clean('2.5 minutes')
+        datetime.timedelta(0, 150)
+        >>> t.clean('2 minutes, 30 seconds')
+        datetime.timedelta(0, 150)
+        >>> t.clean('.5 hours')
+        datetime.timedelta(0, 1800)
+        >>> t.clean('30 minutes')
+        datetime.timedelta(0, 1800)
+        >>> t.clean('1 hour')
+        datetime.timedelta(0, 3600)
+        >>> t.clean('5.5 hours')
+        datetime.timedelta(0, 19800)
+        >>> t.clean('1 day, 1 hour, 30 mins')
+        datetime.timedelta(1, 5400)
+        >>> t.clean('8 min')
+        datetime.timedelta(0, 480)
+        >>> t.clean('3 days, 12 hours')
+        datetime.timedelta(3, 43200)
+        >>> t.clean('3.5 day')
+        datetime.timedelta(3, 43200)
+        >>> t.clean('1 week')
+        datetime.timedelta(7)
+        >>> t.clean('2 weeks, 2 days')
+        datetime.timedelta(16)
+        >>> try:
+        ...  t.clean(six.u('2 we\xe8k, 2 days'))
+        ... except forms.ValidationError as arg:
+        ...  six.print_(arg.messages[0])
+        Enter a valid time span: e.g. "3 days, 4 hours, 2 minutes"
+        """
+        
+        super(TimedeltaFormField, self).clean(value)
+        if value == '' and not self.required:
+            return ''
+        try:
+            return parse(value)
+        except TypeError:
+            raise forms.ValidationError(self.error_messages['invalid'])
+
+class TimedeltaChoicesField(TimedeltaFormField):
+    def __init__(self, *args, **kwargs):
+        choices = kwargs.pop('choices')
+        defaults = {'widget':forms.Select(choices=choices)}
+        defaults.update(kwargs)
+        super(TimedeltaChoicesField, self).__init__(*args, **defaults)