DateFormatter shows microseconds instead of %f for years <= 1900

azjps · azjps · commit e8fb275eb3a2 · 2015-02-25T11:38:34.000-05:00
It also fails to replace %y or %x correctly, since its strftime implementation replaces only 4-digit years. I added a boolean flag DateFormatter.replace_directives_before_1900: - If False, strftime uses the old implementation, which will not replace %f and which will replace incorrect values for %y and %x. - If True, strftime will first try a few regular expressions to replace %y/%x/%f with the appropriate datetime values. I'm not positive this covers all cases but I don't know of any cases where this fails right now. Add a simple test for DateFormatter with and without this flag. closes #3179 Change-Id: Idff9d06cbc6dc00a3cb8dcf113983d82dbdd3fde
diff --git a/lib/matplotlib/dates.py b/lib/matplotlib/dates.py
@@ -401,6 +401,7 @@ def __init__(self, fmt, tz=None):
             tz = _get_rc_timezone()
         self.fmt = fmt
         self.tz = tz
+        self.replace_directives_before_1900 = False
 
     def __call__(self, x, pos=0):
         if x == 0:
@@ -426,16 +427,28 @@ def _findall(self, text, substr):
             i = j + 1
         return sites
 
-    # Dalke: I hope I did this math right.  Every 28 years the
-    # calendar repeats, except through century leap years excepting
-    # the 400 year leap years.  But only if you're using the Gregorian
-    # calendar.
+    def strftime_pre_1900(self, dt, fmt, replace_directives=False):
+        """Call time.strftime for years before 1900 by rolling
+        forward a multiple of 28 years.
 
-    def strftime(self, dt, fmt):
-        fmt = self.illegal_s.sub(r"\1", fmt)
-        fmt = fmt.replace("%s", "s")
-        if dt.year > 1900:
-            return cbook.unicode_safe(dt.strftime(fmt))
+        Dalke: I hope I did this math right.  Every 28 years the
+        calendar repeats, except through century leap years excepting
+        the 400 year leap years.  But only if you're using the Gregorian
+        calendar.
+
+        This implementation uses time's strftime and only handles 4-digit
+        years.  If replace_directive is set to True, as a hack we try and
+        replace %y %x %f with the appropriate values.
+        """
+        if replace_directives:
+          replace_map = \
+              {'f': '{:06d}'.format(dt.microsecond),
+               'x': '{:02d}/{:02d}/{:02d}'.format(dt.month, dt.day, dt.year % 100),
+               'y': '{:02d}'.format(dt.year % 100)}
+          for directive, replacement in replace_map.items():
+            # Replace all (odd # of %s) followed by f, x, or y
+            fmt = re.sub(r'((^|[^%])(%%)*)%' + directive,
+                         r'\g<1>' + replacement, fmt)
 
         year = dt.year
         # For every non-leap year century, advance by
@@ -444,7 +457,7 @@ def strftime(self, dt, fmt):
         off = 6 * (delta // 100 + delta // 400)
         year = year + off
 
-        # Move to around the year 2000
+        # Move to between the years 1973 and 2000
         year = year + ((2000 - year) // 28) * 28
         timetuple = dt.timetuple()
         s1 = time.strftime(fmt, (year,) + timetuple[1:])
@@ -453,6 +466,10 @@ def strftime(self, dt, fmt):
         s2 = time.strftime(fmt, (year + 28,) + timetuple[1:])
         sites2 = self._findall(s2, str(year + 28))
 
+        # Generate timestamp string for year and year+28, and replace
+        # instances of respective years in same location with dt's year
+        # TODO: similar fixes should be applied for %y %x, which
+        # output the year without its century (2-digit, in [00,99])
         sites = []
         for site in sites1:
             if site in sites2:
@@ -465,6 +482,22 @@ def strftime(self, dt, fmt):
 
         return cbook.unicode_safe(s)
 
+    def strftime(self, dt, fmt):
+        """Refer to documentation for datetime.strftime.
+
+        Warning: For years before 1900, the following datetime directives
+        will not work: %y %x %f.  An attempt to replace these can be
+        enabled by setting replace_directives_before_1900 = True.
+        """
+        fmt = self.illegal_s.sub(r"\1", fmt)
+        fmt = fmt.replace("%s", "s")
+        if dt.year >= 1900:
+            # Note: in python 3.3 this is okay for years >= 1000,
+            # refer to http://bugs.python.org/issue177742
+            return cbook.unicode_safe(dt.strftime(fmt))
+
+        return self.strftime_pre_1900(dt, fmt, self.replace_directives_before_1900)
+
 
 class IndexDateFormatter(ticker.Formatter):
     """
diff --git a/lib/matplotlib/tests/test_dates.py b/lib/matplotlib/tests/test_dates.py
@@ -159,6 +159,45 @@ def test_DateFormatter():
     fig.autofmt_xdate()
 
 
+def test_date_formatter_strftime():
+    """
+    Tests that DateFormatter matches datetime.strftime,
+    check microseconds for years before 1900 for bug #3179.
+    """
+    def test_strftime_fields(dt):
+        """For datetime object dt, check DateFormatter fields"""
+        formatter = mdates.DateFormatter("%w %d %m %Y %H %I %M %S")
+        # Compute date fields without using datetime.strftime,
+        # since datetime.strftime does not work before year 1900
+        formatted_date_str = (
+            "{weekday} {day:02d} {month:02d} {full_year:4d} "
+            "{hour24:02d} {hour12:02d} {minute:02d} {second:02d}"
+            .format(
+            # weeknum=dt.isocalendar()[1],  # %U/%W {weeknum:02d}
+            # %w Sunday=0, weekday() Monday=0
+            weekday=str((dt.weekday() + 1) % 7),
+            day=dt.day,
+            month=dt.month,
+            full_year=dt.year,
+            hour24=dt.hour,
+            hour12=((dt.hour-1) % 12) + 1,
+            minute=dt.minute,
+            second=dt.second))
+        assert_equal(formatter.strftime(dt, formatter.fmt), formatted_date_str)
+
+        formatter2 = mdates.DateFormatter("%y %f %x")
+        formatter2.replace_directives_before_1900 = True
+        formatted_date_str2 = (
+            "{year:02d} {microsecond:06d} {month:02d}/{day:02d}/{year:02d}".format(
+            day=dt.day, month=dt.month, year=dt.year % 100, microsecond=dt.microsecond))
+        assert_equal(formatter2.strftime(dt, formatter2.fmt), formatted_date_str2)
+
+    for year in range(1, 3000, 71):
+        # Iterate through random set of years
+        test_strftime_fields(datetime.datetime(year, 1, 1))
+        test_strftime_fields(datetime.datetime(year, 2, 3, 4, 5, 6, 123456))
+
+
 def test_date_formatter_callable():
     scale = -11
     locator = mock.Mock(_get_unit=mock.Mock(return_value=scale))
