Ticket #22355: timedelta_templatetag_with_tests_and_docs.diff

django/template/defaultfilters.py

@@ -18 +18 @@
 from django.utils.text import Truncator, wrap, phone2numeric
 from django.utils.safestring import mark_safe, SafeData, mark_for_escaping
 from django.utils import six
-from django.utils.timesince import timesince, timeuntil
+from django.utils.timesince import timesince, timeuntil, delta
 from django.utils.translation import ugettext, ungettext
 from django.utils.text import normalize_newlines
 
@@ -743 +743 @@
     except (ValueError, TypeError):
         return ''
 
+@register.filter("delta", is_safe=False)
+def delta_filter(value):
+    """Humanizes a timedelta object on template (i.e. "2 months, 2 weeks")."""
+    if not value:
+        return ''
+    try:
+        return delta(value)
+    except (ValueError, TypeError):
+        return ''
+
 ###################
 # LOGIC           #
 ###################

django/utils/timesince.py

@@ -6 +6 @@
 from django.utils.timezone import is_aware, utc
 from django.utils.translation import ugettext, ungettext_lazy
 
-def timesince(d, now=None, reversed=False):
+def time_to_text(time_delta):
     """
-    Takes two datetime objects and returns the time between d and now
-    as a nicely formatted string, e.g. "10 minutes".  If d occurs after now,
-    then "0 minutes" is returned.
-
-    Units used are years, months, weeks, days, hours, and minutes.
-    Seconds and microseconds are ignored.  Up to two adjacent units will be
-    displayed.  For example, "2 weeks, 3 days" and "1 year, 3 months" are
-    possible outputs, but "2 weeks, 3 hours" and "1 year, 5 days" are not.
-
-    Adapted from
-    http://web.archive.org/web/20060617175230/http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
+    Converts a datetime.timedelta object into a nicely formatted
+    humanized string. Used by timesince, timeuntil and delta utils functions
     """
     chunks = (
         (60 * 60 * 24 * 365, ungettext_lazy('%d year', '%d years')),
@@ -28 +19 @@
         (60 * 60, ungettext_lazy('%d hour', '%d hours')),
         (60, ungettext_lazy('%d minute', '%d minutes'))
     )
-    # Convert datetime.date to datetime.datetime for comparison.
-    if not isinstance(d, datetime.datetime):
-        d = datetime.datetime(d.year, d.month, d.day)
-    if now and not isinstance(now, datetime.datetime):
-        now = datetime.datetime(now.year, now.month, now.day)
-
-    if not now:
-        now = datetime.datetime.now(utc if is_aware(d) else None)
-
-    delta = (d - now) if reversed else (now - d)
     # ignore microseconds
     since = delta.days * 24 * 60 * 60 + delta.seconds
     if since <= 0:
@@ -56 +37 @@
             result += ugettext(', ') + avoid_wrapping(name2 % count2)
     return result
 
+def timesince(d, now=None, reversed=False):
+    """
+    Takes two datetime objects and returns the time between d and now
+    as a nicely formatted string, e.g. "10 minutes".  If d occurs after now,
+    then "0 minutes" is returned.
+
+    Units used are years, months, weeks, days, hours, and minutes.
+    Seconds and microseconds are ignored.  Up to two adjacent units will be
+    displayed.  For example, "2 weeks, 3 days" and "1 year, 3 months" are
+    possible outputs, but "2 weeks, 3 hours" and "1 year, 5 days" are not.
+
+    Adapted from
+    http://web.archive.org/web/20060617175230/http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
+    """
+
+    if isinstance(d, datetime.timedelta):
+        time_delta = d
+    else:
+        # Convert datetime.date to datetime.datetime for comparison.
+        if not isinstance(d, datetime.datetime):
+            d = datetime.datetime(d.year, d.month, d.day)
+        if now and not isinstance(now, datetime.datetime):
+            now = datetime.datetime(now.year, now.month, now.day)
+        if not now:
+            now = datetime.datetime.now(utc if is_aware(d) else None)
+        time_delta = (d - now) if reversed else (now - d)
+    result = time_to_text(time_delta)
+    return result
+
 def timeuntil(d, now=None):
     """
     Like timesince, but returns a string measuring the time until
     the given time.
     """
     return timesince(d, now, reversed=True)
+
+def delta(time_delta):
+    """
+    Returns seconds duration as weeks, days, hours, minutes, seconds
+    Similar to timesince/timeuntil, but works with datetime.timedelta
+    """
+    return timesince(time_delta)
+ No newline at end of file

docs/ref/templates/builtins.txt

@@ -2088 +2088 @@
 Minutes is the smallest unit used, and "0 minutes" will be returned for any
 date that is in the past relative to the comparison point.
 
+.. templatefilter:: delta
+
+delta
+^^^^^^^^^
+
+Similar to ``timesince`` and ``timeuntil``, except that it can take timedelta
+as argument. For example, if user has been working on a task for a timespan,
+and``working_time`` is a timedelta instance holding
+``datetime.timedelta(1, 43199, 999989)``, then ``{{ working_time|delta }}``
+will return "1 day, 11 hours".
+
+
+As like ``timesince`` and ``timeuntil``, minutes is the smallest unit used,
+and "0 minutes" will be returned for any date that is in the past relative
+to the comparison point.
+
 .. templatefilter:: title
 
 title

tests/defaultfilters/tests.py

@@ -552 +552 @@
                              datetime.datetime(2005, 12, 29)),
             '1\xa0day')
 
+    def test_delta(self):
+        self.assertEqual(
+            delta_filter(datetime.timedelta(29, 64788)),
+                         '4\xa0weeks, 1\xa0day')
+
     def test_default(self):
         self.assertEqual(default("val", "default"), 'val')
         self.assertEqual(default(None, "default"), 'default')

tests/template_tests/filters.py

@@ -90 +90 @@
         'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
         'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1\xa0day'),
 
+        # Compare to a given parameter
+        'filter-delta01' : ('{{ a|delta }}', {'a': timedelta(29, 64788)}, u'4\xa0weeks, 1\xa0day'),
+        'filter-delta02' : ('{{ a|delta }}', {'a': now - (datetime.now() - timedelta(hours=36))}, '1\xa0day, 11\xa0hours'),
+
         'filter-addslash01': ("{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}", {"a": "<a>'", "b": mark_safe("<a>'")}, r"<a>\' <a>\'"),
         'filter-addslash02': ("{{ a|addslashes }} {{ b|addslashes }}", {"a": "<a>'", "b": mark_safe("<a>'")}, r"&lt;a&gt;\&#39; <a>\'"),
 

tests/utils_tests/test_timesince.py

@@ -3 +3 @@
 import datetime
 import unittest
 
-from django.utils.timesince import timesince, timeuntil
+from django.utils.timesince import timesince, timeuntil, delta
 from django.utils.tzinfo import LocalTimezone, FixedOffset
 
 class TimesinceTests(unittest.TestCase):
@@ -123 +123 @@
         self.assertEqual(timesince(future), '0\xa0minutes')
         past = datetime.datetime(1980, 1, 1, tzinfo=naive())
         self.assertEqual(timeuntil(past), '0\xa0minutes')
+
+    def test_delta_with_timedelta_objects(self):
+        time_delta = datetime.timedelta(1, 43199, 999989)
+        self.assertEqual(delta(time_delta), '1\xa0day, 11\xa0hours')
+