pylint: upgrade to 1.3.1

third_party/logilab/common/date.py

-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of logilab-common.
 #
 # logilab-common is free software: you can redistribute it and/or modify it under
 # the terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 2.1 of the License, or (at your option) any
 # later version.
 #
 # logilab-common is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
 """Date manipulation helper functions."""
 from __future__ import division
 
 __docformat__ = "restructuredtext en"
 
 import math
 import re
-from locale import getpreferredencoding
+import sys
+from locale import getlocale, LC_TIME
 from datetime import date, time, datetime, timedelta
 from time import strptime as time_strptime
 from calendar import monthrange, timegm
 
+from six.moves import range
+
 try:
     from mx.DateTime import RelativeDateTime, Date, DateTimeType
 except ImportError:
     endOfMonth = None
     DateTimeType = datetime
 else:
     endOfMonth = RelativeDateTime(months=1, day=-1)
 
 # NOTE: should we implement a compatibility layer between date representations
 #       as we have in lgc.db ?
@@ skipping 83 matching lines @@
         return delta.days
     else:
         return int(math.ceil((end - start).days))
 
 def get_national_holidays(begin, end):
     """return french national days off between begin and end"""
     begin = datefactory(begin.year, begin.month, begin.day, begin)
     end = datefactory(end.year, end.month, end.day, end)
     holidays = [str2date(datestr, begin)
                 for datestr in FRENCH_MOBILE_HOLIDAYS.values()]
-    for year in xrange(begin.year, end.year+1):
+    for year in range(begin.year, end.year+1):
         for datestr in FRENCH_FIXED_HOLIDAYS.values():
             date = str2date(datestr % year, begin)
             if date not in holidays:
                 holidays.append(date)
     return [day for day in holidays if begin <= day < end]
 
 def add_days_worked(start, days):
     """adds date but try to only take days worked into account"""
     step = get_step(start)
     weeks, plus = divmod(days, 5)
@@ skipping 36 matching lines @@
 
     When using mx datetime, you should *NOT* use incmonth argument, use instead
     oneDay, oneHour, oneMinute, oneSecond, oneWeek or endOfMonth (to enumerate
     months) as `incday` argument
     """
     assert not (incday and incmonth)
     begin = todate(begin)
     end = todate(end)
     if incmonth:
         while begin < end:
+            yield begin
             begin = next_month(begin, incmonth)
-            yield begin
     else:
         incr = get_step(begin, incday or 1)
         while begin < end:
            yield begin
            begin += incr
 
 # makes py datetime usable #####################################################
 
 ONEDAY = timedelta(days=1)
 ONEWEEK = timedelta(days=7)
@@ skipping 70 matching lines @@
     return somedate
 
 def first_day(somedate):
     return date(somedate.year, somedate.month, 1)
 
 def last_day(somedate):
     return date(somedate.year, somedate.month, days_in_month(somedate))
 
 def ustrftime(somedate, fmt='%Y-%m-%d'):
     """like strftime, but returns a unicode string instead of an encoded
-    string which' may be problematic with localized date.
-
-    encoding is guessed by locale.getpreferredencoding()
+    string which may be problematic with localized date.
     """
-    encoding = getpreferredencoding(do_setlocale=False) or 'UTF-8'
-    try:
-        return unicode(somedate.strftime(str(fmt)), encoding)
-    except ValueError, exc:
-        if somedate.year >= 1900:
-            raise
-        # datetime is not happy with dates before 1900
-        # we try to work around this, assuming a simple
-        # format string
-        fields = {'Y': somedate.year,
-                  'm': somedate.month,
-                  'd': somedate.day,
-                  }
-        if isinstance(somedate, datetime):
-            fields.update({'H': somedate.hour,
-                           'M': somedate.minute,
-                           'S': somedate.second})
-        fmt = re.sub('%([YmdHMS])', r'%(\1)02d', fmt)
-        return unicode(fmt) % fields
+    if sys.version_info >= (3, 3):
+        # datetime.date.strftime() supports dates since year 1 in Python >=3.3.
+        return somedate.strftime(fmt)
+    else:
+        try:
+            if sys.version_info < (3, 0):
+                encoding = getlocale(LC_TIME)[1] or 'ascii'
+                return unicode(somedate.strftime(str(fmt)), encoding)
+            else:
+                return somedate.strftime(fmt)
+        except ValueError:
+            if somedate.year >= 1900:
+                raise
+            # datetime is not happy with dates before 1900
+            # we try to work around this, assuming a simple
+            # format string
+            fields = {'Y': somedate.year,
+                      'm': somedate.month,
+                      'd': somedate.day,
+                      }
+            if isinstance(somedate, datetime):
+                fields.update({'H': somedate.hour,
+                               'M': somedate.minute,
+                               'S': somedate.second})
+            fmt = re.sub('%([YmdHMS])', r'%(\1)02d', fmt)
+            return unicode(fmt) % fields
 
 def utcdatetime(dt):
     if dt.tzinfo is None:
         return dt
     return datetime(*dt.utctimetuple()[:7])
 
 def utctime(dt):
     if dt.tzinfo is None:
         return dt
     return (dt + dt.utcoffset() + dt.dst()).replace(tzinfo=None)
 
 def datetime_to_seconds(date):
     """return the number of seconds since the begining of the day for that date
     """
     return date.second+60*date.minute + 3600*date.hour
 
 def timedelta_to_days(delta):
     """return the time delta as a number of seconds"""
     return delta.days + delta.seconds / (3600*24)
 
 def timedelta_to_seconds(delta):
     """return the time delta as a fraction of days"""
     return delta.days*(3600*24) + delta.seconds