Restoring authorship annotation for <wawaka@yandex-team.ru>. Commit 2 of 2.

8 files changed, 2152 insertions, 2152 deletions

diff --git a/contrib/python/dateutil/dateutil/__init__.py b/contrib/python/dateutil/dateutil/__init__.py
index 67644df2d4..0defb82e21 100644
--- a/contrib/python/dateutil/dateutil/__init__.py
+++ b/contrib/python/dateutil/dateutil/__init__.py
@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 try:
     from ._version import version as __version__
 except ImportError:
diff --git a/contrib/python/dateutil/dateutil/easter.py b/contrib/python/dateutil/dateutil/easter.py
index 09a0f6d7de..f74d1f7442 100644
--- a/contrib/python/dateutil/dateutil/easter.py
+++ b/contrib/python/dateutil/dateutil/easter.py
@@ -1,89 +1,89 @@
-# -*- coding: utf-8 -*- 
-""" 
+# -*- coding: utf-8 -*-
+"""
 This module offers a generic Easter computing method for any given year, using
-Western, Orthodox or Julian algorithms. 
-""" 
- 
-import datetime 
- 
-__all__ = ["easter", "EASTER_JULIAN", "EASTER_ORTHODOX", "EASTER_WESTERN"] 
- 
-EASTER_JULIAN = 1 
-EASTER_ORTHODOX = 2 
-EASTER_WESTERN = 3 
- 
- 
-def easter(year, method=EASTER_WESTERN): 
-    """ 
-    This method was ported from the work done by GM Arts, 
-    on top of the algorithm by Claus Tondering, which was 
-    based in part on the algorithm of Ouding (1940), as 
-    quoted in "Explanatory Supplement to the Astronomical 
-    Almanac", P.  Kenneth Seidelmann, editor. 
- 
+Western, Orthodox or Julian algorithms.
+"""
+
+import datetime
+
+__all__ = ["easter", "EASTER_JULIAN", "EASTER_ORTHODOX", "EASTER_WESTERN"]
+
+EASTER_JULIAN = 1
+EASTER_ORTHODOX = 2
+EASTER_WESTERN = 3
+
+
+def easter(year, method=EASTER_WESTERN):
+    """
+    This method was ported from the work done by GM Arts,
+    on top of the algorithm by Claus Tondering, which was
+    based in part on the algorithm of Ouding (1940), as
+    quoted in "Explanatory Supplement to the Astronomical
+    Almanac", P.  Kenneth Seidelmann, editor.
+
     This algorithm implements three different Easter
-    calculation methods: 
- 
+    calculation methods:
+
     1. Original calculation in Julian calendar, valid in
        dates after 326 AD
     2. Original method, with date converted to Gregorian
        calendar, valid in years 1583 to 4099
     3. Revised method, in Gregorian calendar, valid in
        years 1583 to 4099 as well
- 
-    These methods are represented by the constants: 
- 
+
+    These methods are represented by the constants:
+
     * ``EASTER_JULIAN   = 1``
     * ``EASTER_ORTHODOX = 2``
     * ``EASTER_WESTERN  = 3``
- 
-    The default method is method 3. 
- 
-    More about the algorithm may be found at: 
- 
+
+    The default method is method 3.
+
+    More about the algorithm may be found at:
+
     `GM Arts: Easter Algorithms <http://www.gmarts.org/index.php?go=415>`_
- 
-    and 
- 
+
+    and
+
     `The Calendar FAQ: Easter <https://www.tondering.dk/claus/cal/easter.php>`_
- 
-    """ 
- 
-    if not (1 <= method <= 3): 
-        raise ValueError("invalid method") 
- 
-    # g - Golden year - 1 
-    # c - Century 
-    # h - (23 - Epact) mod 30 
-    # i - Number of days from March 21 to Paschal Full Moon 
-    # j - Weekday for PFM (0=Sunday, etc) 
-    # p - Number of days from March 21 to Sunday on or before PFM 
-    #     (-6 to 28 methods 1 & 3, to 56 for method 2) 
-    # e - Extra days to add for method 2 (converting Julian 
-    #     date to Gregorian date) 
- 
-    y = year 
-    g = y % 19 
-    e = 0 
-    if method < 3: 
-        # Old method 
-        i = (19*g + 15) % 30 
-        j = (y + y//4 + i) % 7 
-        if method == 2: 
-            # Extra dates to convert Julian to Gregorian date 
-            e = 10 
-            if y > 1600: 
-                e = e + y//100 - 16 - (y//100 - 16)//4 
-    else: 
-        # New method 
-        c = y//100 
-        h = (c - c//4 - (8*c + 13)//25 + 19*g + 15) % 30 
-        i = h - (h//28)*(1 - (h//28)*(29//(h + 1))*((21 - g)//11)) 
-        j = (y + y//4 + i + 2 - c + c//4) % 7 
- 
-    # p can be from -6 to 56 corresponding to dates 22 March to 23 May 
-    # (later dates apply to method 2, although 23 May never actually occurs) 
-    p = i - j + e 
-    d = 1 + (p + 27 + (p + 6)//40) % 31 
-    m = 3 + (p + 26)//30 
-    return datetime.date(int(y), int(m), int(d)) 
+
+    """
+
+    if not (1 <= method <= 3):
+        raise ValueError("invalid method")
+
+    # g - Golden year - 1
+    # c - Century
+    # h - (23 - Epact) mod 30
+    # i - Number of days from March 21 to Paschal Full Moon
+    # j - Weekday for PFM (0=Sunday, etc)
+    # p - Number of days from March 21 to Sunday on or before PFM
+    #     (-6 to 28 methods 1 & 3, to 56 for method 2)
+    # e - Extra days to add for method 2 (converting Julian
+    #     date to Gregorian date)
+
+    y = year
+    g = y % 19
+    e = 0
+    if method < 3:
+        # Old method
+        i = (19*g + 15) % 30
+        j = (y + y//4 + i) % 7
+        if method == 2:
+            # Extra dates to convert Julian to Gregorian date
+            e = 10
+            if y > 1600:
+                e = e + y//100 - 16 - (y//100 - 16)//4
+    else:
+        # New method
+        c = y//100
+        h = (c - c//4 - (8*c + 13)//25 + 19*g + 15) % 30
+        i = h - (h//28)*(1 - (h//28)*(29//(h + 1))*((21 - g)//11))
+        j = (y + y//4 + i + 2 - c + c//4) % 7
+
+    # p can be from -6 to 56 corresponding to dates 22 March to 23 May
+    # (later dates apply to method 2, although 23 May never actually occurs)
+    p = i - j + e
+    d = 1 + (p + 27 + (p + 6)//40) % 31
+    m = 3 + (p + 26)//30
+    return datetime.date(int(y), int(m), int(d))
diff --git a/contrib/python/dateutil/dateutil/relativedelta.py b/contrib/python/dateutil/dateutil/relativedelta.py
index 79b3e87b97..a9e85f7e6c 100644
--- a/contrib/python/dateutil/dateutil/relativedelta.py
+++ b/contrib/python/dateutil/dateutil/relativedelta.py
@@ -1,22 +1,22 @@
-# -*- coding: utf-8 -*- 
-import datetime 
-import calendar 
- 
+# -*- coding: utf-8 -*-
+import datetime
+import calendar
+
 import operator
 from math import copysign
 
-from six import integer_types 
+from six import integer_types
 from warnings import warn
- 
+
 from ._common import weekday
- 
+
 MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))
- 
+
 __all__ = ["relativedelta", "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
- 
- 
-class relativedelta(object): 
-    """ 
+
+
+class relativedelta(object):
+    """
     The relativedelta type is designed to be applied to an existing datetime and
     can replace specific components of that datetime, or represents an interval
     of time.
@@ -26,28 +26,28 @@ class relativedelta(object):
     `mx.DateTime <https://www.egenix.com/products/python/mxBase/mxDateTime/>`_ extension.
     However, notice that this type does *NOT* implement the same algorithm as
     his work. Do *NOT* expect it to behave like mx.DateTime's counterpart.
- 
+
     There are two different ways to build a relativedelta instance. The
     first one is passing it two date/datetime classes::
- 
+
         relativedelta(datetime1, datetime2)
- 
+
     The second one is passing it any number of the following keyword arguments::
- 
+
         relativedelta(arg1=x,arg2=y,arg3=z...)
- 
+
         year, month, day, hour, minute, second, microsecond:
             Absolute information (argument is singular); adding or subtracting a
             relativedelta with absolute information does not perform an arithmetic
             operation, but rather REPLACES the corresponding value in the
             original datetime with the value(s) in relativedelta.
- 
+
         years, months, weeks, days, hours, minutes, seconds, microseconds:
             Relative information, may be negative (argument is plural); adding
             or subtracting a relativedelta with relative information performs
             the corresponding arithmetic operation on the original datetime value
             with the information in the relativedelta.
- 
+
         weekday: 
             One of the weekday instances (MO, TU, etc) available in the
             relativedelta module. These instances may receive a parameter N,
@@ -58,24 +58,24 @@ class relativedelta(object):
             or MO(-1) won't change the day. To effectively make it absolute, use
             it in combination with the day argument (e.g. day=1, MO(1) for first
             Monday of the month).
- 
+
         leapdays:
             Will add given days to the date found, if year is a leap
             year, and the date found is post 28 of february.
- 
+
         yearday, nlyearday:
             Set the yearday or the non-leap year day (jump leap days).
             These are converted to day/month/leapdays information.
- 
+
     There are relative and absolute forms of the keyword
     arguments. The plural is relative, and the singular is
     absolute. For each argument in the order below, the absolute form
     is applied first (by setting each attribute to that value) and
     then the relative form (by adding the value to the attribute).
- 
+
     The order of attributes considered when this relativedelta is
     added to a datetime is:
- 
+
     1. Year
     2. Month
     3. Day
@@ -83,78 +83,78 @@ class relativedelta(object):
     5. Minutes
     6. Seconds
     7. Microseconds
- 
+
     Finally, weekday is applied, using the rule described above.
- 
+
     For example
- 
+
     >>> from datetime import datetime
     >>> from dateutil.relativedelta import relativedelta, MO
     >>> dt = datetime(2018, 4, 9, 13, 37, 0)
     >>> delta = relativedelta(hours=25, day=1, weekday=MO(1))
     >>> dt + delta
     datetime.datetime(2018, 4, 2, 14, 37)
- 
+
     First, the day is set to 1 (the first of the month), then 25 hours
     are added, to get to the 2nd day and 14th hour, finally the
     weekday is applied, but since the 2nd is already a Monday there is
     no effect.
 
-    """ 
- 
-    def __init__(self, dt1=None, dt2=None, 
-                 years=0, months=0, days=0, leapdays=0, weeks=0, 
-                 hours=0, minutes=0, seconds=0, microseconds=0, 
-                 year=None, month=None, day=None, weekday=None, 
-                 yearday=None, nlyearday=None, 
-                 hour=None, minute=None, second=None, microsecond=None): 
+    """
 
-        if dt1 and dt2: 
+    def __init__(self, dt1=None, dt2=None,
+                 years=0, months=0, days=0, leapdays=0, weeks=0,
+                 hours=0, minutes=0, seconds=0, microseconds=0,
+                 year=None, month=None, day=None, weekday=None,
+                 yearday=None, nlyearday=None,
+                 hour=None, minute=None, second=None, microsecond=None):
+
+        if dt1 and dt2:
             # datetime is a subclass of date. So both must be date
-            if not (isinstance(dt1, datetime.date) and 
-                    isinstance(dt2, datetime.date)): 
-                raise TypeError("relativedelta only diffs datetime/date") 
+            if not (isinstance(dt1, datetime.date) and
+                    isinstance(dt2, datetime.date)):
+                raise TypeError("relativedelta only diffs datetime/date")
 
             # We allow two dates, or two datetimes, so we coerce them to be
             # of the same type
             if (isinstance(dt1, datetime.datetime) !=
                     isinstance(dt2, datetime.datetime)):
-                if not isinstance(dt1, datetime.datetime): 
-                    dt1 = datetime.datetime.fromordinal(dt1.toordinal()) 
-                elif not isinstance(dt2, datetime.datetime): 
-                    dt2 = datetime.datetime.fromordinal(dt2.toordinal()) 
-
-            self.years = 0 
-            self.months = 0 
-            self.days = 0 
-            self.leapdays = 0 
-            self.hours = 0 
-            self.minutes = 0 
-            self.seconds = 0 
-            self.microseconds = 0 
-            self.year = None 
-            self.month = None 
-            self.day = None 
-            self.weekday = None 
-            self.hour = None 
-            self.minute = None 
-            self.second = None 
-            self.microsecond = None 
-            self._has_time = 0 
- 
+                if not isinstance(dt1, datetime.datetime):
+                    dt1 = datetime.datetime.fromordinal(dt1.toordinal())
+                elif not isinstance(dt2, datetime.datetime):
+                    dt2 = datetime.datetime.fromordinal(dt2.toordinal())
+
+            self.years = 0
+            self.months = 0
+            self.days = 0
+            self.leapdays = 0
+            self.hours = 0
+            self.minutes = 0
+            self.seconds = 0
+            self.microseconds = 0
+            self.year = None
+            self.month = None
+            self.day = None
+            self.weekday = None
+            self.hour = None
+            self.minute = None
+            self.second = None
+            self.microsecond = None
+            self._has_time = 0
+
             # Get year / month delta between the two
             months = (dt1.year - dt2.year) * 12 + (dt1.month - dt2.month)
-            self._set_months(months) 
+            self._set_months(months)
 
             # Remove the year/month delta so the timedelta is just well-defined
             # time units (seconds, days and microseconds)
-            dtm = self.__radd__(dt2) 
+            dtm = self.__radd__(dt2)
 
             # If we've overshot our target, make an adjustment
-            if dt1 < dt2: 
+            if dt1 < dt2:
                 compare = operator.gt
                 increment = 1
-            else: 
+            else:
                 compare = operator.lt
                 increment = -1
 
@@ -164,10 +164,10 @@ class relativedelta(object):
                 dtm = self.__radd__(dt2)
 
             # Get the timedelta between the "months-adjusted" date and dt1
-            delta = dt1 - dtm 
+            delta = dt1 - dtm
             self.seconds = delta.seconds + delta.days * 86400
-            self.microseconds = delta.microseconds 
-        else: 
+            self.microseconds = delta.microseconds
+        else:
             # Check for non-integer values in integer-only quantities
             if any(x is not None and x != int(x) for x in (years, months)):
                 raise ValueError("Non-integer years and months are "
@@ -177,21 +177,21 @@ class relativedelta(object):
             self.years = int(years)
             self.months = int(months)
             self.days = days + weeks * 7
-            self.leapdays = leapdays 
-            self.hours = hours 
-            self.minutes = minutes 
-            self.seconds = seconds 
-            self.microseconds = microseconds 
+            self.leapdays = leapdays
+            self.hours = hours
+            self.minutes = minutes
+            self.seconds = seconds
+            self.microseconds = microseconds
 
             # Absolute information
-            self.year = year 
-            self.month = month 
-            self.day = day 
-            self.hour = hour 
-            self.minute = minute 
-            self.second = second 
-            self.microsecond = microsecond 
- 
+            self.year = year
+            self.month = month
+            self.day = day
+            self.hour = hour
+            self.minute = minute
+            self.second = second
+            self.microsecond = microsecond
+
             if any(x is not None and int(x) != x
                    for x in (year, month, day, hour,
                              minute, second, microsecond)):
@@ -200,67 +200,67 @@ class relativedelta(object):
                      "This is not a well-defined condition and will raise " +
                      "errors in future versions.", DeprecationWarning)
 
-            if isinstance(weekday, integer_types): 
-                self.weekday = weekdays[weekday] 
-            else: 
-                self.weekday = weekday 
- 
-            yday = 0 
-            if nlyearday: 
-                yday = nlyearday 
-            elif yearday: 
-                yday = yearday 
-                if yearday > 59: 
-                    self.leapdays = -1 
-            if yday: 
-                ydayidx = [31, 59, 90, 120, 151, 181, 212, 
-                           243, 273, 304, 334, 366] 
-                for idx, ydays in enumerate(ydayidx): 
-                    if yday <= ydays: 
-                        self.month = idx+1 
-                        if idx == 0: 
-                            self.day = yday 
-                        else: 
-                            self.day = yday-ydayidx[idx-1] 
-                        break 
-                else: 
-                    raise ValueError("invalid year day (%d)" % yday) 
- 
-        self._fix() 
- 
-    def _fix(self): 
-        if abs(self.microseconds) > 999999: 
+            if isinstance(weekday, integer_types):
+                self.weekday = weekdays[weekday]
+            else:
+                self.weekday = weekday
+
+            yday = 0
+            if nlyearday:
+                yday = nlyearday
+            elif yearday:
+                yday = yearday
+                if yearday > 59:
+                    self.leapdays = -1
+            if yday:
+                ydayidx = [31, 59, 90, 120, 151, 181, 212,
+                           243, 273, 304, 334, 366]
+                for idx, ydays in enumerate(ydayidx):
+                    if yday <= ydays:
+                        self.month = idx+1
+                        if idx == 0:
+                            self.day = yday
+                        else:
+                            self.day = yday-ydayidx[idx-1]
+                        break
+                else:
+                    raise ValueError("invalid year day (%d)" % yday)
+
+        self._fix()
+
+    def _fix(self):
+        if abs(self.microseconds) > 999999:
             s = _sign(self.microseconds)
             div, mod = divmod(self.microseconds * s, 1000000)
             self.microseconds = mod * s
             self.seconds += div * s
-        if abs(self.seconds) > 59: 
+        if abs(self.seconds) > 59:
             s = _sign(self.seconds)
             div, mod = divmod(self.seconds * s, 60)
             self.seconds = mod * s
             self.minutes += div * s
-        if abs(self.minutes) > 59: 
+        if abs(self.minutes) > 59:
             s = _sign(self.minutes)
             div, mod = divmod(self.minutes * s, 60)
             self.minutes = mod * s
             self.hours += div * s
-        if abs(self.hours) > 23: 
+        if abs(self.hours) > 23:
             s = _sign(self.hours)
             div, mod = divmod(self.hours * s, 24)
             self.hours = mod * s
             self.days += div * s
-        if abs(self.months) > 11: 
+        if abs(self.months) > 11:
             s = _sign(self.months)
             div, mod = divmod(self.months * s, 12)
             self.months = mod * s
             self.years += div * s
-        if (self.hours or self.minutes or self.seconds or self.microseconds 
-                or self.hour is not None or self.minute is not None or 
-                self.second is not None or self.microsecond is not None): 
-            self._has_time = 1 
-        else: 
-            self._has_time = 0 
- 
+        if (self.hours or self.minutes or self.seconds or self.microseconds
+                or self.hour is not None or self.minute is not None or
+                self.second is not None or self.microsecond is not None):
+            self._has_time = 1
+        else:
+            self._has_time = 0
+
     @property
     def weeks(self):
         return int(self.days / 7.0)
@@ -269,16 +269,16 @@ class relativedelta(object):
     def weeks(self, value):
         self.days = self.days - (self.weeks * 7) + value * 7
 
-    def _set_months(self, months): 
-        self.months = months 
-        if abs(self.months) > 11: 
+    def _set_months(self, months):
+        self.months = months
+        if abs(self.months) > 11:
             s = _sign(self.months)
             div, mod = divmod(self.months * s, 12)
             self.months = mod * s
             self.years = div * s
-        else: 
-            self.years = 0 
- 
+        else:
+            self.years = 0
+
     def normalized(self):
         """
         Return a version of this object represented entirely using integer
@@ -314,17 +314,17 @@ class relativedelta(object):
                               minute=self.minute, second=self.second,
                               microsecond=self.microsecond)
 
-    def __add__(self, other): 
-        if isinstance(other, relativedelta): 
+    def __add__(self, other):
+        if isinstance(other, relativedelta):
             return self.__class__(years=other.years + self.years,
                                  months=other.months + self.months,
                                  days=other.days + self.days,
                                  hours=other.hours + self.hours,
                                  minutes=other.minutes + self.minutes,
                                  seconds=other.seconds + self.seconds,
-                                 microseconds=(other.microseconds + 
-                                               self.microseconds), 
-                                 leapdays=other.leapdays or self.leapdays, 
+                                 microseconds=(other.microseconds +
+                                               self.microseconds),
+                                 leapdays=other.leapdays or self.leapdays,
                                  year=(other.year if other.year is not None
                                        else self.year),
                                  month=(other.month if other.month is not None
@@ -341,7 +341,7 @@ class relativedelta(object):
                                          else self.second),
                                  microsecond=(other.microsecond if other.microsecond
                                               is not None else
-                                              self.microsecond)) 
+                                              self.microsecond))
         if isinstance(other, datetime.timedelta):
             return self.__class__(years=self.years,
                                   months=self.months,
@@ -359,56 +359,56 @@ class relativedelta(object):
                                   minute=self.minute,
                                   second=self.second,
                                   microsecond=self.microsecond)
-        if not isinstance(other, datetime.date): 
+        if not isinstance(other, datetime.date):
             return NotImplemented
-        elif self._has_time and not isinstance(other, datetime.datetime): 
-            other = datetime.datetime.fromordinal(other.toordinal()) 
-        year = (self.year or other.year)+self.years 
-        month = self.month or other.month 
-        if self.months: 
-            assert 1 <= abs(self.months) <= 12 
-            month += self.months 
-            if month > 12: 
-                year += 1 
-                month -= 12 
-            elif month < 1: 
-                year -= 1 
-                month += 12 
-        day = min(calendar.monthrange(year, month)[1], 
-                  self.day or other.day) 
-        repl = {"year": year, "month": month, "day": day} 
-        for attr in ["hour", "minute", "second", "microsecond"]: 
-            value = getattr(self, attr) 
-            if value is not None: 
-                repl[attr] = value 
-        days = self.days 
-        if self.leapdays and month > 2 and calendar.isleap(year): 
-            days += self.leapdays 
-        ret = (other.replace(**repl) 
-               + datetime.timedelta(days=days, 
-                                    hours=self.hours, 
-                                    minutes=self.minutes, 
-                                    seconds=self.seconds, 
-                                    microseconds=self.microseconds)) 
-        if self.weekday: 
-            weekday, nth = self.weekday.weekday, self.weekday.n or 1 
+        elif self._has_time and not isinstance(other, datetime.datetime):
+            other = datetime.datetime.fromordinal(other.toordinal())
+        year = (self.year or other.year)+self.years
+        month = self.month or other.month
+        if self.months:
+            assert 1 <= abs(self.months) <= 12
+            month += self.months
+            if month > 12:
+                year += 1
+                month -= 12
+            elif month < 1:
+                year -= 1
+                month += 12
+        day = min(calendar.monthrange(year, month)[1],
+                  self.day or other.day)
+        repl = {"year": year, "month": month, "day": day}
+        for attr in ["hour", "minute", "second", "microsecond"]:
+            value = getattr(self, attr)
+            if value is not None:
+                repl[attr] = value
+        days = self.days
+        if self.leapdays and month > 2 and calendar.isleap(year):
+            days += self.leapdays
+        ret = (other.replace(**repl)
+               + datetime.timedelta(days=days,
+                                    hours=self.hours,
+                                    minutes=self.minutes,
+                                    seconds=self.seconds,
+                                    microseconds=self.microseconds))
+        if self.weekday:
+            weekday, nth = self.weekday.weekday, self.weekday.n or 1
             jumpdays = (abs(nth) - 1) * 7
-            if nth > 0: 
+            if nth > 0:
                 jumpdays += (7 - ret.weekday() + weekday) % 7
-            else: 
+            else:
                 jumpdays += (ret.weekday() - weekday) % 7
-                jumpdays *= -1 
-            ret += datetime.timedelta(days=jumpdays) 
-        return ret 
- 
-    def __radd__(self, other): 
-        return self.__add__(other) 
- 
-    def __rsub__(self, other): 
-        return self.__neg__().__radd__(other) 
- 
-    def __sub__(self, other): 
-        if not isinstance(other, relativedelta): 
+                jumpdays *= -1
+            ret += datetime.timedelta(days=jumpdays)
+        return ret
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __rsub__(self, other):
+        return self.__neg__().__radd__(other)
+
+    def __sub__(self, other):
+        if not isinstance(other, relativedelta):
             return NotImplemented   # In case the other object defines __rsub__
         return self.__class__(years=self.years - other.years,
                              months=self.months - other.months,
@@ -417,7 +417,7 @@ class relativedelta(object):
                              minutes=self.minutes - other.minutes,
                              seconds=self.seconds - other.seconds,
                              microseconds=self.microseconds - other.microseconds,
-                             leapdays=self.leapdays or other.leapdays, 
+                             leapdays=self.leapdays or other.leapdays,
                              year=(self.year if self.year is not None
                                    else other.year),
                              month=(self.month if self.month is not None else
@@ -435,7 +435,7 @@ class relativedelta(object):
                              microsecond=(self.microsecond if self.microsecond
                                           is not None else
                                           other.microsecond))
- 
+
     def __abs__(self):
         return self.__class__(years=abs(self.years),
                               months=abs(self.months),
@@ -454,45 +454,45 @@ class relativedelta(object):
                               second=self.second,
                               microsecond=self.microsecond)
 
-    def __neg__(self): 
+    def __neg__(self):
         return self.__class__(years=-self.years,
-                             months=-self.months, 
-                             days=-self.days, 
-                             hours=-self.hours, 
-                             minutes=-self.minutes, 
-                             seconds=-self.seconds, 
-                             microseconds=-self.microseconds, 
-                             leapdays=self.leapdays, 
-                             year=self.year, 
-                             month=self.month, 
-                             day=self.day, 
-                             weekday=self.weekday, 
-                             hour=self.hour, 
-                             minute=self.minute, 
-                             second=self.second, 
-                             microsecond=self.microsecond) 
- 
-    def __bool__(self): 
-        return not (not self.years and 
-                    not self.months and 
-                    not self.days and 
-                    not self.hours and 
-                    not self.minutes and 
-                    not self.seconds and 
-                    not self.microseconds and 
-                    not self.leapdays and 
-                    self.year is None and 
-                    self.month is None and 
-                    self.day is None and 
-                    self.weekday is None and 
-                    self.hour is None and 
-                    self.minute is None and 
-                    self.second is None and 
-                    self.microsecond is None) 
+                             months=-self.months,
+                             days=-self.days,
+                             hours=-self.hours,
+                             minutes=-self.minutes,
+                             seconds=-self.seconds,
+                             microseconds=-self.microseconds,
+                             leapdays=self.leapdays,
+                             year=self.year,
+                             month=self.month,
+                             day=self.day,
+                             weekday=self.weekday,
+                             hour=self.hour,
+                             minute=self.minute,
+                             second=self.second,
+                             microsecond=self.microsecond)
+
+    def __bool__(self):
+        return not (not self.years and
+                    not self.months and
+                    not self.days and
+                    not self.hours and
+                    not self.minutes and
+                    not self.seconds and
+                    not self.microseconds and
+                    not self.leapdays and
+                    self.year is None and
+                    self.month is None and
+                    self.day is None and
+                    self.weekday is None and
+                    self.hour is None and
+                    self.minute is None and
+                    self.second is None and
+                    self.microsecond is None)
     # Compatibility with Python 2.x
     __nonzero__ = __bool__
- 
-    def __mul__(self, other): 
+
+    def __mul__(self, other):
         try:
             f = float(other)
         except TypeError:
@@ -505,45 +505,45 @@ class relativedelta(object):
                              minutes=int(self.minutes * f),
                              seconds=int(self.seconds * f),
                              microseconds=int(self.microseconds * f),
-                             leapdays=self.leapdays, 
-                             year=self.year, 
-                             month=self.month, 
-                             day=self.day, 
-                             weekday=self.weekday, 
-                             hour=self.hour, 
-                             minute=self.minute, 
-                             second=self.second, 
-                             microsecond=self.microsecond) 
- 
-    __rmul__ = __mul__ 
- 
-    def __eq__(self, other): 
-        if not isinstance(other, relativedelta): 
+                             leapdays=self.leapdays,
+                             year=self.year,
+                             month=self.month,
+                             day=self.day,
+                             weekday=self.weekday,
+                             hour=self.hour,
+                             minute=self.minute,
+                             second=self.second,
+                             microsecond=self.microsecond)
+
+    __rmul__ = __mul__
+
+    def __eq__(self, other):
+        if not isinstance(other, relativedelta):
             return NotImplemented
-        if self.weekday or other.weekday: 
-            if not self.weekday or not other.weekday: 
-                return False 
-            if self.weekday.weekday != other.weekday.weekday: 
-                return False 
-            n1, n2 = self.weekday.n, other.weekday.n 
-            if n1 != n2 and not ((not n1 or n1 == 1) and (not n2 or n2 == 1)): 
-                return False 
-        return (self.years == other.years and 
-                self.months == other.months and 
-                self.days == other.days and 
-                self.hours == other.hours and 
-                self.minutes == other.minutes and 
-                self.seconds == other.seconds and 
+        if self.weekday or other.weekday:
+            if not self.weekday or not other.weekday:
+                return False
+            if self.weekday.weekday != other.weekday.weekday:
+                return False
+            n1, n2 = self.weekday.n, other.weekday.n
+            if n1 != n2 and not ((not n1 or n1 == 1) and (not n2 or n2 == 1)):
+                return False
+        return (self.years == other.years and
+                self.months == other.months and
+                self.days == other.days and
+                self.hours == other.hours and
+                self.minutes == other.minutes and
+                self.seconds == other.seconds and
                 self.microseconds == other.microseconds and
-                self.leapdays == other.leapdays and 
-                self.year == other.year and 
-                self.month == other.month and 
-                self.day == other.day and 
-                self.hour == other.hour and 
-                self.minute == other.minute and 
-                self.second == other.second and 
-                self.microsecond == other.microsecond) 
- 
+                self.leapdays == other.leapdays and
+                self.year == other.year and
+                self.month == other.month and
+                self.day == other.day and
+                self.hour == other.hour and
+                self.minute == other.minute and
+                self.second == other.second and
+                self.microsecond == other.microsecond)
+
     def __hash__(self):
         return hash((
             self.weekday,
@@ -564,36 +564,36 @@ class relativedelta(object):
             self.microsecond,
         ))
 
-    def __ne__(self, other): 
-        return not self.__eq__(other) 
- 
-    def __div__(self, other): 
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __div__(self, other):
         try:
             reciprocal = 1 / float(other)
         except TypeError:
             return NotImplemented
- 
+
         return self.__mul__(reciprocal)
 
-    __truediv__ = __div__ 
- 
-    def __repr__(self): 
-        l = [] 
-        for attr in ["years", "months", "days", "leapdays", 
-                     "hours", "minutes", "seconds", "microseconds"]: 
-            value = getattr(self, attr) 
-            if value: 
+    __truediv__ = __div__
+
+    def __repr__(self):
+        l = []
+        for attr in ["years", "months", "days", "leapdays",
+                     "hours", "minutes", "seconds", "microseconds"]:
+            value = getattr(self, attr)
+            if value:
                 l.append("{attr}={value:+g}".format(attr=attr, value=value))
-        for attr in ["year", "month", "day", "weekday", 
-                     "hour", "minute", "second", "microsecond"]: 
-            value = getattr(self, attr) 
-            if value is not None: 
+        for attr in ["year", "month", "day", "weekday",
+                     "hour", "minute", "second", "microsecond"]:
+            value = getattr(self, attr)
+            if value is not None:
                 l.append("{attr}={value}".format(attr=attr, value=repr(value)))
         return "{classname}({attrs})".format(classname=self.__class__.__name__,
                                              attrs=", ".join(l))
- 
+
 
 def _sign(x):
     return int(copysign(1, x))
 
-# vim:ts=4:sw=4:et 
+# vim:ts=4:sw=4:et
diff --git a/contrib/python/dateutil/dateutil/rrule.py b/contrib/python/dateutil/dateutil/rrule.py
index 73b6811f24..b3203393c6 100644
--- a/contrib/python/dateutil/dateutil/rrule.py
+++ b/contrib/python/dateutil/dateutil/rrule.py
@@ -1,24 +1,24 @@
-# -*- coding: utf-8 -*- 
-""" 
-The rrule module offers a small, complete, and very fast, implementation of 
-the recurrence rules documented in the 
+# -*- coding: utf-8 -*-
+"""
+The rrule module offers a small, complete, and very fast, implementation of
+the recurrence rules documented in the
 `iCalendar RFC <https://tools.ietf.org/html/rfc5545>`_,
-including support for caching of results. 
-""" 
+including support for caching of results.
+"""
 import calendar
 import datetime
 import heapq
-import itertools 
+import itertools
 import re
-import sys 
+import sys
 from functools import wraps
 # For warning about deprecation of until and count
 from warnings import warn
- 
+
 from six import advance_iterator, integer_types
 
 from six.moves import _thread, range
- 
+
 from ._common import weekday as weekdaybase
 
 try:
@@ -26,57 +26,57 @@ try:
 except ImportError:
     from fractions import gcd
 
-__all__ = ["rrule", "rruleset", "rrulestr", 
-           "YEARLY", "MONTHLY", "WEEKLY", "DAILY", 
-           "HOURLY", "MINUTELY", "SECONDLY", 
-           "MO", "TU", "WE", "TH", "FR", "SA", "SU"] 
- 
-# Every mask is 7 days longer to handle cross-year weekly periods. 
-M366MASK = tuple([1]*31+[2]*29+[3]*31+[4]*30+[5]*31+[6]*30 + 
-                 [7]*31+[8]*31+[9]*30+[10]*31+[11]*30+[12]*31+[1]*7) 
-M365MASK = list(M366MASK) 
-M29, M30, M31 = list(range(1, 30)), list(range(1, 31)), list(range(1, 32)) 
-MDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7]) 
-MDAY365MASK = list(MDAY366MASK) 
-M29, M30, M31 = list(range(-29, 0)), list(range(-30, 0)), list(range(-31, 0)) 
-NMDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7]) 
-NMDAY365MASK = list(NMDAY366MASK) 
-M366RANGE = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366) 
-M365RANGE = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365) 
-WDAYMASK = [0, 1, 2, 3, 4, 5, 6]*55 
-del M29, M30, M31, M365MASK[59], MDAY365MASK[59], NMDAY365MASK[31] 
-MDAY365MASK = tuple(MDAY365MASK) 
-M365MASK = tuple(M365MASK) 
- 
+__all__ = ["rrule", "rruleset", "rrulestr",
+           "YEARLY", "MONTHLY", "WEEKLY", "DAILY",
+           "HOURLY", "MINUTELY", "SECONDLY",
+           "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
+
+# Every mask is 7 days longer to handle cross-year weekly periods.
+M366MASK = tuple([1]*31+[2]*29+[3]*31+[4]*30+[5]*31+[6]*30 +
+                 [7]*31+[8]*31+[9]*30+[10]*31+[11]*30+[12]*31+[1]*7)
+M365MASK = list(M366MASK)
+M29, M30, M31 = list(range(1, 30)), list(range(1, 31)), list(range(1, 32))
+MDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])
+MDAY365MASK = list(MDAY366MASK)
+M29, M30, M31 = list(range(-29, 0)), list(range(-30, 0)), list(range(-31, 0))
+NMDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])
+NMDAY365MASK = list(NMDAY366MASK)
+M366RANGE = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366)
+M365RANGE = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365)
+WDAYMASK = [0, 1, 2, 3, 4, 5, 6]*55
+del M29, M30, M31, M365MASK[59], MDAY365MASK[59], NMDAY365MASK[31]
+MDAY365MASK = tuple(MDAY365MASK)
+M365MASK = tuple(M365MASK)
+
 FREQNAMES = ['YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY', 'HOURLY', 'MINUTELY', 'SECONDLY']
 
-(YEARLY, 
- MONTHLY, 
- WEEKLY, 
- DAILY, 
- HOURLY, 
- MINUTELY, 
- SECONDLY) = list(range(7)) 
- 
-# Imported on demand. 
-easter = None 
-parser = None 
- 
- 
+(YEARLY,
+ MONTHLY,
+ WEEKLY,
+ DAILY,
+ HOURLY,
+ MINUTELY,
+ SECONDLY) = list(range(7))
+
+# Imported on demand.
+easter = None
+parser = None
+
+
 class weekday(weekdaybase):
     """
     This version of weekday does not allow n = 0.
     """
     def __init__(self, wkday, n=None):
-        if n == 0: 
+        if n == 0:
             raise ValueError("Can't create weekday with n==0")
- 
+
         super(weekday, self).__init__(wkday, n)
- 
- 
+
+
 MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))
- 
- 
+
+
 def _invalidates_cache(f):
     """
     Decorator for rruleset methods which may invalidate the
@@ -87,29 +87,29 @@ def _invalidates_cache(f):
         rv = f(self, *args, **kwargs)
         self._invalidate_cache()
         return rv
- 
+
     return inner_func
 
 
-class rrulebase(object): 
-    def __init__(self, cache=False): 
-        if cache: 
-            self._cache = [] 
-            self._cache_lock = _thread.allocate_lock() 
+class rrulebase(object):
+    def __init__(self, cache=False):
+        if cache:
+            self._cache = []
+            self._cache_lock = _thread.allocate_lock()
             self._invalidate_cache()
-        else: 
-            self._cache = None 
-            self._cache_complete = False 
+        else:
+            self._cache = None
+            self._cache_complete = False
             self._len = None
- 
-    def __iter__(self): 
-        if self._cache_complete: 
-            return iter(self._cache) 
-        elif self._cache is None: 
-            return self._iter() 
-        else: 
-            return self._iter_cached() 
- 
+
+    def __iter__(self):
+        if self._cache_complete:
+            return iter(self._cache)
+        elif self._cache is None:
+            return self._iter()
+        else:
+            return self._iter_cached()
+
     def _invalidate_cache(self):
         if self._cache is not None:
             self._cache = []
@@ -121,112 +121,112 @@ class rrulebase(object):
 
         self._len = None
 
-    def _iter_cached(self): 
-        i = 0 
-        gen = self._cache_gen 
-        cache = self._cache 
-        acquire = self._cache_lock.acquire 
-        release = self._cache_lock.release 
-        while gen: 
-            if i == len(cache): 
-                acquire() 
-                if self._cache_complete: 
-                    break 
-                try: 
-                    for j in range(10): 
-                        cache.append(advance_iterator(gen)) 
-                except StopIteration: 
-                    self._cache_gen = gen = None 
-                    self._cache_complete = True 
-                    break 
-                release() 
-            yield cache[i] 
-            i += 1 
-        while i < self._len: 
-            yield cache[i] 
-            i += 1 
- 
-    def __getitem__(self, item): 
-        if self._cache_complete: 
-            return self._cache[item] 
-        elif isinstance(item, slice): 
-            if item.step and item.step < 0: 
-                return list(iter(self))[item] 
-            else: 
-                return list(itertools.islice(self, 
-                                             item.start or 0, 
-                                             item.stop or sys.maxsize, 
-                                             item.step or 1)) 
-        elif item >= 0: 
-            gen = iter(self) 
-            try: 
-                for i in range(item+1): 
-                    res = advance_iterator(gen) 
-            except StopIteration: 
-                raise IndexError 
-            return res 
-        else: 
-            return list(iter(self))[item] 
- 
-    def __contains__(self, item): 
-        if self._cache_complete: 
-            return item in self._cache 
-        else: 
-            for i in self: 
-                if i == item: 
-                    return True 
-                elif i > item: 
-                    return False 
-        return False 
- 
+    def _iter_cached(self):
+        i = 0
+        gen = self._cache_gen
+        cache = self._cache
+        acquire = self._cache_lock.acquire
+        release = self._cache_lock.release
+        while gen:
+            if i == len(cache):
+                acquire()
+                if self._cache_complete:
+                    break
+                try:
+                    for j in range(10):
+                        cache.append(advance_iterator(gen))
+                except StopIteration:
+                    self._cache_gen = gen = None
+                    self._cache_complete = True
+                    break
+                release()
+            yield cache[i]
+            i += 1
+        while i < self._len:
+            yield cache[i]
+            i += 1
+
+    def __getitem__(self, item):
+        if self._cache_complete:
+            return self._cache[item]
+        elif isinstance(item, slice):
+            if item.step and item.step < 0:
+                return list(iter(self))[item]
+            else:
+                return list(itertools.islice(self,
+                                             item.start or 0,
+                                             item.stop or sys.maxsize,
+                                             item.step or 1))
+        elif item >= 0:
+            gen = iter(self)
+            try:
+                for i in range(item+1):
+                    res = advance_iterator(gen)
+            except StopIteration:
+                raise IndexError
+            return res
+        else:
+            return list(iter(self))[item]
+
+    def __contains__(self, item):
+        if self._cache_complete:
+            return item in self._cache
+        else:
+            for i in self:
+                if i == item:
+                    return True
+                elif i > item:
+                    return False
+        return False
+
     # __len__() introduces a large performance penalty.
-    def count(self): 
-        """ Returns the number of recurrences in this set. It will have go 
-            trough the whole recurrence, if this hasn't been done before. """ 
-        if self._len is None: 
-            for x in self: 
-                pass 
-        return self._len 
- 
-    def before(self, dt, inc=False): 
-        """ Returns the last recurrence before the given datetime instance. The 
-            inc keyword defines what happens if dt is an occurrence. With 
-            inc=True, if dt itself is an occurrence, it will be returned. """ 
-        if self._cache_complete: 
-            gen = self._cache 
-        else: 
-            gen = self 
-        last = None 
-        if inc: 
-            for i in gen: 
-                if i > dt: 
-                    break 
-                last = i 
-        else: 
-            for i in gen: 
-                if i >= dt: 
-                    break 
-                last = i 
-        return last 
- 
-    def after(self, dt, inc=False): 
-        """ Returns the first recurrence after the given datetime instance. The 
-            inc keyword defines what happens if dt is an occurrence. With 
-            inc=True, if dt itself is an occurrence, it will be returned.  """ 
-        if self._cache_complete: 
-            gen = self._cache 
-        else: 
-            gen = self 
-        if inc: 
-            for i in gen: 
-                if i >= dt: 
-                    return i 
-        else: 
-            for i in gen: 
-                if i > dt: 
-                    return i 
-        return None 
- 
+    def count(self):
+        """ Returns the number of recurrences in this set. It will have go
+            trough the whole recurrence, if this hasn't been done before. """
+        if self._len is None:
+            for x in self:
+                pass
+        return self._len
+
+    def before(self, dt, inc=False):
+        """ Returns the last recurrence before the given datetime instance. The
+            inc keyword defines what happens if dt is an occurrence. With
+            inc=True, if dt itself is an occurrence, it will be returned. """
+        if self._cache_complete:
+            gen = self._cache
+        else:
+            gen = self
+        last = None
+        if inc:
+            for i in gen:
+                if i > dt:
+                    break
+                last = i
+        else:
+            for i in gen:
+                if i >= dt:
+                    break
+                last = i
+        return last
+
+    def after(self, dt, inc=False):
+        """ Returns the first recurrence after the given datetime instance. The
+            inc keyword defines what happens if dt is an occurrence. With
+            inc=True, if dt itself is an occurrence, it will be returned.  """
+        if self._cache_complete:
+            gen = self._cache
+        else:
+            gen = self
+        if inc:
+            for i in gen:
+                if i >= dt:
+                    return i
+        else:
+            for i in gen:
+                if i > dt:
+                    return i
+        return None
+
     def xafter(self, dt, count=None, inc=False):
         """
         Generator which yields up to `count` recurrences after the given
@@ -269,50 +269,50 @@ class rrulebase(object):
                 yield d
 
     def between(self, after, before, inc=False, count=1):
-        """ Returns all the occurrences of the rrule between after and before. 
-        The inc keyword defines what happens if after and/or before are 
-        themselves occurrences. With inc=True, they will be included in the 
-        list, if they are found in the recurrence set. """ 
-        if self._cache_complete: 
-            gen = self._cache 
-        else: 
-            gen = self 
-        started = False 
-        l = [] 
-        if inc: 
-            for i in gen: 
-                if i > before: 
-                    break 
-                elif not started: 
-                    if i >= after: 
-                        started = True 
-                        l.append(i) 
-                else: 
-                    l.append(i) 
-        else: 
-            for i in gen: 
-                if i >= before: 
-                    break 
-                elif not started: 
-                    if i > after: 
-                        started = True 
-                        l.append(i) 
-                else: 
-                    l.append(i) 
-        return l 
- 
- 
-class rrule(rrulebase): 
-    """ 
-    That's the base of the rrule operation. It accepts all the keywords 
-    defined in the RFC as its constructor parameters (except byday, 
-    which was renamed to byweekday) and more. The constructor prototype is:: 
- 
-            rrule(freq) 
- 
-    Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, 
-    or SECONDLY. 
- 
+        """ Returns all the occurrences of the rrule between after and before.
+        The inc keyword defines what happens if after and/or before are
+        themselves occurrences. With inc=True, they will be included in the
+        list, if they are found in the recurrence set. """
+        if self._cache_complete:
+            gen = self._cache
+        else:
+            gen = self
+        started = False
+        l = []
+        if inc:
+            for i in gen:
+                if i > before:
+                    break
+                elif not started:
+                    if i >= after:
+                        started = True
+                        l.append(i)
+                else:
+                    l.append(i)
+        else:
+            for i in gen:
+                if i >= before:
+                    break
+                elif not started:
+                    if i > after:
+                        started = True
+                        l.append(i)
+                else:
+                    l.append(i)
+        return l
+
+
+class rrule(rrulebase):
+    """
+    That's the base of the rrule operation. It accepts all the keywords
+    defined in the RFC as its constructor parameters (except byday,
+    which was renamed to byweekday) and more. The constructor prototype is::
+
+            rrule(freq)
+
+    Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,
+    or SECONDLY.
+
     .. note::
         Per RFC section 3.3.10, recurrence instances falling on invalid dates
         and times are ignored rather than coerced:
@@ -336,24 +336,24 @@ class rrule(rrulebase):
          datetime.datetime(2015, 3, 31, 0, 0),
          datetime.datetime(2015, 5, 31, 0, 0)]
 
-    Additionally, it supports the following keyword arguments: 
- 
-    :param dtstart: 
-        The recurrence start. Besides being the base for the recurrence, 
-        missing parameters in the final recurrence instances will also be 
-        extracted from this date. If not given, datetime.now() will be used 
-        instead. 
-    :param interval: 
-        The interval between each freq iteration. For example, when using 
-        YEARLY, an interval of 2 means once every two years, but with HOURLY, 
-        it means once every two hours. The default interval is 1. 
-    :param wkst: 
-        The week start day. Must be one of the MO, TU, WE constants, or an 
-        integer, specifying the first day of the week. This will affect 
-        recurrences based on weekly periods. The default week start is got 
-        from calendar.firstweekday(), and may be modified by 
-        calendar.setfirstweekday(). 
-    :param count: 
+    Additionally, it supports the following keyword arguments:
+
+    :param dtstart:
+        The recurrence start. Besides being the base for the recurrence,
+        missing parameters in the final recurrence instances will also be
+        extracted from this date. If not given, datetime.now() will be used
+        instead.
+    :param interval:
+        The interval between each freq iteration. For example, when using
+        YEARLY, an interval of 2 means once every two years, but with HOURLY,
+        it means once every two hours. The default interval is 1.
+    :param wkst:
+        The week start day. Must be one of the MO, TU, WE constants, or an
+        integer, specifying the first day of the week. This will affect
+        recurrences based on weekly periods. The default week start is got
+        from calendar.firstweekday(), and may be modified by
+        calendar.setfirstweekday().
+    :param count:
         If given, this determines how many occurrences will be generated.
 
         .. note::
@@ -362,7 +362,7 @@ class rrule(rrulebase):
             compliant with `RFC-5545 Sec. 3.3.10 <https://tools.ietf.org/
             html/rfc5545#section-3.3.10>`_. Therefore, ``until`` and ``count``
             **must not** occur in the same call to ``rrule``.
-    :param until: 
+    :param until:
         If given, this must be a datetime instance specifying the upper-bound
         limit of the recurrence. The last recurrence in the rule is the greatest
         datetime that is less than or equal to the value specified in the
@@ -374,79 +374,79 @@ class rrule(rrulebase):
             compliant with `RFC-5545 Sec. 3.3.10 <https://tools.ietf.org/
             html/rfc5545#section-3.3.10>`_. Therefore, ``until`` and ``count``
             **must not** occur in the same call to ``rrule``.
-    :param bysetpos: 
-        If given, it must be either an integer, or a sequence of integers, 
-        positive or negative. Each given integer will specify an occurrence 
-        number, corresponding to the nth occurrence of the rule inside the 
-        frequency period. For example, a bysetpos of -1 if combined with a 
-        MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will 
-        result in the last work day of every month. 
-    :param bymonth: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the months to apply the recurrence to. 
-    :param bymonthday: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the month days to apply the recurrence to. 
-    :param byyearday: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the year days to apply the recurrence to. 
+    :param bysetpos:
+        If given, it must be either an integer, or a sequence of integers,
+        positive or negative. Each given integer will specify an occurrence
+        number, corresponding to the nth occurrence of the rule inside the
+        frequency period. For example, a bysetpos of -1 if combined with a
+        MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will
+        result in the last work day of every month.
+    :param bymonth:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the months to apply the recurrence to.
+    :param bymonthday:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the month days to apply the recurrence to.
+    :param byyearday:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the year days to apply the recurrence to.
     :param byeaster:
         If given, it must be either an integer, or a sequence of integers,
         positive or negative. Each integer will define an offset from the
         Easter Sunday. Passing the offset 0 to byeaster will yield the Easter
         Sunday itself. This is an extension to the RFC specification.
-    :param byweekno: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the week numbers to apply the recurrence to. Week numbers 
-        have the meaning described in ISO8601, that is, the first week of 
-        the year is that containing at least four days of the new year. 
-    :param byweekday: 
-        If given, it must be either an integer (0 == MO), a sequence of 
-        integers, one of the weekday constants (MO, TU, etc), or a sequence 
-        of these constants. When given, these variables will define the 
-        weekdays where the recurrence will be applied. It's also possible to 
-        use an argument n for the weekday instances, which will mean the nth 
-        occurrence of this weekday in the period. For example, with MONTHLY, 
-        or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the 
-        first friday of the month where the recurrence happens. Notice that in 
-        the RFC documentation, this is specified as BYDAY, but was renamed to 
-        avoid the ambiguity of that keyword. 
-    :param byhour: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the hours to apply the recurrence to. 
-    :param byminute: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the minutes to apply the recurrence to. 
-    :param bysecond: 
-        If given, it must be either an integer, or a sequence of integers, 
-        meaning the seconds to apply the recurrence to. 
+    :param byweekno:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the week numbers to apply the recurrence to. Week numbers
+        have the meaning described in ISO8601, that is, the first week of
+        the year is that containing at least four days of the new year.
+    :param byweekday:
+        If given, it must be either an integer (0 == MO), a sequence of
+        integers, one of the weekday constants (MO, TU, etc), or a sequence
+        of these constants. When given, these variables will define the
+        weekdays where the recurrence will be applied. It's also possible to
+        use an argument n for the weekday instances, which will mean the nth
+        occurrence of this weekday in the period. For example, with MONTHLY,
+        or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the
+        first friday of the month where the recurrence happens. Notice that in
+        the RFC documentation, this is specified as BYDAY, but was renamed to
+        avoid the ambiguity of that keyword.
+    :param byhour:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the hours to apply the recurrence to.
+    :param byminute:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the minutes to apply the recurrence to.
+    :param bysecond:
+        If given, it must be either an integer, or a sequence of integers,
+        meaning the seconds to apply the recurrence to.
     :param cache:
         If given, it must be a boolean value specifying to enable or disable
         caching of results. If you will use the same rrule instance multiple
         times, enabling caching will improve the performance considerably.
-     """ 
-    def __init__(self, freq, dtstart=None, 
-                 interval=1, wkst=None, count=None, until=None, bysetpos=None, 
-                 bymonth=None, bymonthday=None, byyearday=None, byeaster=None, 
-                 byweekno=None, byweekday=None, 
-                 byhour=None, byminute=None, bysecond=None, 
-                 cache=False): 
-        super(rrule, self).__init__(cache) 
-        global easter 
-        if not dtstart: 
+     """
+    def __init__(self, freq, dtstart=None,
+                 interval=1, wkst=None, count=None, until=None, bysetpos=None,
+                 bymonth=None, bymonthday=None, byyearday=None, byeaster=None,
+                 byweekno=None, byweekday=None,
+                 byhour=None, byminute=None, bysecond=None,
+                 cache=False):
+        super(rrule, self).__init__(cache)
+        global easter
+        if not dtstart:
             if until and until.tzinfo:
                 dtstart = datetime.datetime.now(tz=until.tzinfo).replace(microsecond=0)
             else:
                 dtstart = datetime.datetime.now().replace(microsecond=0)
-        elif not isinstance(dtstart, datetime.datetime): 
-            dtstart = datetime.datetime.fromordinal(dtstart.toordinal()) 
-        else: 
-            dtstart = dtstart.replace(microsecond=0) 
-        self._dtstart = dtstart 
-        self._tzinfo = dtstart.tzinfo 
-        self._freq = freq 
-        self._interval = interval 
-        self._count = count 
+        elif not isinstance(dtstart, datetime.datetime):
+            dtstart = datetime.datetime.fromordinal(dtstart.toordinal())
+        else:
+            dtstart = dtstart.replace(microsecond=0)
+        self._dtstart = dtstart
+        self._tzinfo = dtstart.tzinfo
+        self._freq = freq
+        self._interval = interval
+        self._count = count
 
         # Cache the original byxxx rules, if they are provided, as the _byxxx
         # attributes do not necessarily map to the inputs, and this can be
@@ -454,9 +454,9 @@ class rrule(rrulebase):
         # been supplied (the string retrieval will just use .get())
         self._original_rule = {}
 
-        if until and not isinstance(until, datetime.datetime): 
-            until = datetime.datetime.fromordinal(until.toordinal()) 
-        self._until = until 
+        if until and not isinstance(until, datetime.datetime):
+            until = datetime.datetime.fromordinal(until.toordinal())
+        self._until = until
 
         if self._dtstart and self._until:
             if (self._dtstart.tzinfo is not None) != (self._until.tzinfo is not None):
@@ -477,49 +477,49 @@ class rrule(rrulebase):
                  " and has been deprecated in dateutil. Future versions will "
                  "raise an error.", DeprecationWarning)
 
-        if wkst is None: 
-            self._wkst = calendar.firstweekday() 
-        elif isinstance(wkst, integer_types): 
-            self._wkst = wkst 
-        else: 
-            self._wkst = wkst.weekday 
-
-        if bysetpos is None: 
-            self._bysetpos = None 
-        elif isinstance(bysetpos, integer_types): 
-            if bysetpos == 0 or not (-366 <= bysetpos <= 366): 
-                raise ValueError("bysetpos must be between 1 and 366, " 
-                                 "or between -366 and -1") 
-            self._bysetpos = (bysetpos,) 
-        else: 
-            self._bysetpos = tuple(bysetpos) 
-            for pos in self._bysetpos: 
-                if pos == 0 or not (-366 <= pos <= 366): 
-                    raise ValueError("bysetpos must be between 1 and 366, " 
-                                     "or between -366 and -1") 
+        if wkst is None:
+            self._wkst = calendar.firstweekday()
+        elif isinstance(wkst, integer_types):
+            self._wkst = wkst
+        else:
+            self._wkst = wkst.weekday
+
+        if bysetpos is None:
+            self._bysetpos = None
+        elif isinstance(bysetpos, integer_types):
+            if bysetpos == 0 or not (-366 <= bysetpos <= 366):
+                raise ValueError("bysetpos must be between 1 and 366, "
+                                 "or between -366 and -1")
+            self._bysetpos = (bysetpos,)
+        else:
+            self._bysetpos = tuple(bysetpos)
+            for pos in self._bysetpos:
+                if pos == 0 or not (-366 <= pos <= 366):
+                    raise ValueError("bysetpos must be between 1 and 366, "
+                                     "or between -366 and -1")
 
         if self._bysetpos:
             self._original_rule['bysetpos'] = self._bysetpos
 
         if (byweekno is None and byyearday is None and bymonthday is None and
                 byweekday is None and byeaster is None):
-            if freq == YEARLY: 
+            if freq == YEARLY:
                 if bymonth is None:
-                    bymonth = dtstart.month 
+                    bymonth = dtstart.month
                     self._original_rule['bymonth'] = None
-                bymonthday = dtstart.day 
+                bymonthday = dtstart.day
                 self._original_rule['bymonthday'] = None
-            elif freq == MONTHLY: 
-                bymonthday = dtstart.day 
+            elif freq == MONTHLY:
+                bymonthday = dtstart.day
                 self._original_rule['bymonthday'] = None
-            elif freq == WEEKLY: 
-                byweekday = dtstart.weekday() 
+            elif freq == WEEKLY:
+                byweekday = dtstart.weekday()
                 self._original_rule['byweekday'] = None
 
-        # bymonth 
+        # bymonth
         if bymonth is None:
-            self._bymonth = None 
-        else: 
+            self._bymonth = None
+        else:
             if isinstance(bymonth, integer_types):
                 bymonth = (bymonth,)
 
@@ -528,34 +528,34 @@ class rrule(rrulebase):
             if 'bymonth' not in self._original_rule:
                 self._original_rule['bymonth'] = self._bymonth
 
-        # byyearday 
+        # byyearday
         if byyearday is None:
-            self._byyearday = None 
-        else: 
+            self._byyearday = None
+        else:
             if isinstance(byyearday, integer_types):
                 byyearday = (byyearday,)
 
             self._byyearday = tuple(sorted(set(byyearday)))
             self._original_rule['byyearday'] = self._byyearday
 
-        # byeaster 
-        if byeaster is not None: 
-            if not easter: 
-                from dateutil import easter 
-            if isinstance(byeaster, integer_types): 
-                self._byeaster = (byeaster,) 
-            else: 
+        # byeaster
+        if byeaster is not None:
+            if not easter:
+                from dateutil import easter
+            if isinstance(byeaster, integer_types):
+                self._byeaster = (byeaster,)
+            else:
                 self._byeaster = tuple(sorted(byeaster))
 
             self._original_rule['byeaster'] = self._byeaster
-        else: 
-            self._byeaster = None 
+        else:
+            self._byeaster = None
 
         # bymonthday
         if bymonthday is None:
-            self._bymonthday = () 
-            self._bynmonthday = () 
-        else: 
+            self._bymonthday = ()
+            self._bynmonthday = ()
+        else:
             if isinstance(bymonthday, integer_types):
                 bymonthday = (bymonthday,)
 
@@ -569,10 +569,10 @@ class rrule(rrulebase):
                 self._original_rule['bymonthday'] = tuple(
                     itertools.chain(self._bymonthday, self._bynmonthday))
 
-        # byweekno 
-        if byweekno is None: 
-            self._byweekno = None 
-        else: 
+        # byweekno
+        if byweekno is None:
+            self._byweekno = None
+        else:
             if isinstance(byweekno, integer_types):
                 byweekno = (byweekno,)
 
@@ -580,11 +580,11 @@ class rrule(rrulebase):
 
             self._original_rule['byweekno'] = self._byweekno
 
-        # byweekday / bynweekday 
-        if byweekday is None: 
-            self._byweekday = None 
-            self._bynweekday = None 
-        else: 
+        # byweekday / bynweekday
+        if byweekday is None:
+            self._byweekday = None
+            self._bynweekday = None
+        else:
             # If it's one of the valid non-sequence types, convert to a
             # single-element sequence before the iterator that builds the
             # byweekday set.
@@ -593,18 +593,18 @@ class rrule(rrulebase):
 
             self._byweekday = set()
             self._bynweekday = set()
-            for wday in byweekday: 
-                if isinstance(wday, integer_types): 
+            for wday in byweekday:
+                if isinstance(wday, integer_types):
                     self._byweekday.add(wday)
-                elif not wday.n or freq > MONTHLY: 
+                elif not wday.n or freq > MONTHLY:
                     self._byweekday.add(wday.weekday)
-                else: 
+                else:
                     self._bynweekday.add((wday.weekday, wday.n))
 
-            if not self._byweekday: 
-                self._byweekday = None 
-            elif not self._bynweekday: 
-                self._bynweekday = None 
+            if not self._byweekday:
+                self._byweekday = None
+            elif not self._bynweekday:
+                self._bynweekday = None
 
             if self._byweekday is not None:
                 self._byweekday = tuple(sorted(self._byweekday))
@@ -622,13 +622,13 @@ class rrule(rrulebase):
                 self._original_rule['byweekday'] = tuple(itertools.chain(
                     orig_byweekday, orig_bynweekday))
 
-        # byhour 
-        if byhour is None: 
-            if freq < HOURLY: 
+        # byhour
+        if byhour is None:
+            if freq < HOURLY:
                 self._byhour = {dtstart.hour}
-            else: 
-                self._byhour = None 
-        else: 
+            else:
+                self._byhour = None
+        else:
             if isinstance(byhour, integer_types):
                 byhour = (byhour,)
 
@@ -642,13 +642,13 @@ class rrule(rrulebase):
             self._byhour = tuple(sorted(self._byhour))
             self._original_rule['byhour'] = self._byhour
 
-        # byminute 
-        if byminute is None: 
-            if freq < MINUTELY: 
+        # byminute
+        if byminute is None:
+            if freq < MINUTELY:
                 self._byminute = {dtstart.minute}
-            else: 
-                self._byminute = None 
-        else: 
+            else:
+                self._byminute = None
+        else:
             if isinstance(byminute, integer_types):
                 byminute = (byminute,)
 
@@ -662,16 +662,16 @@ class rrule(rrulebase):
             self._byminute = tuple(sorted(self._byminute))
             self._original_rule['byminute'] = self._byminute
 
-        # bysecond 
-        if bysecond is None: 
-            if freq < SECONDLY: 
+        # bysecond
+        if bysecond is None:
+            if freq < SECONDLY:
                 self._bysecond = ((dtstart.second,))
-            else: 
-                self._bysecond = None 
-        else: 
+            else:
+                self._bysecond = None
+        else:
             if isinstance(bysecond, integer_types):
                 bysecond = (bysecond,)
- 
+
             self._bysecond = set(bysecond)
 
             if freq == SECONDLY:
@@ -684,19 +684,19 @@ class rrule(rrulebase):
             self._bysecond = tuple(sorted(self._bysecond))
             self._original_rule['bysecond'] = self._bysecond
 
-        if self._freq >= HOURLY: 
-            self._timeset = None 
-        else: 
-            self._timeset = [] 
-            for hour in self._byhour: 
-                for minute in self._byminute: 
-                    for second in self._bysecond: 
-                        self._timeset.append( 
-                            datetime.time(hour, minute, second, 
-                                          tzinfo=self._tzinfo)) 
-            self._timeset.sort() 
-            self._timeset = tuple(self._timeset) 
- 
+        if self._freq >= HOURLY:
+            self._timeset = None
+        else:
+            self._timeset = []
+            for hour in self._byhour:
+                for minute in self._byminute:
+                    for second in self._bysecond:
+                        self._timeset.append(
+                            datetime.time(hour, minute, second,
+                                          tzinfo=self._tzinfo))
+            self._timeset.sort()
+            self._timeset = tuple(self._timeset)
+
     def __str__(self):
         """
         Output a string that would generate this RRULE if passed to rrulestr.
@@ -773,165 +773,165 @@ class rrule(rrulebase):
         new_kwargs.update(kwargs)
         return rrule(**new_kwargs)
 
-    def _iter(self): 
-        year, month, day, hour, minute, second, weekday, yearday, _ = \ 
-            self._dtstart.timetuple() 
- 
-        # Some local variables to speed things up a bit 
-        freq = self._freq 
-        interval = self._interval 
-        wkst = self._wkst 
-        until = self._until 
-        bymonth = self._bymonth 
-        byweekno = self._byweekno 
-        byyearday = self._byyearday 
-        byweekday = self._byweekday 
-        byeaster = self._byeaster 
-        bymonthday = self._bymonthday 
-        bynmonthday = self._bynmonthday 
-        bysetpos = self._bysetpos 
-        byhour = self._byhour 
-        byminute = self._byminute 
-        bysecond = self._bysecond 
- 
-        ii = _iterinfo(self) 
-        ii.rebuild(year, month) 
- 
-        getdayset = {YEARLY: ii.ydayset, 
-                     MONTHLY: ii.mdayset, 
-                     WEEKLY: ii.wdayset, 
-                     DAILY: ii.ddayset, 
-                     HOURLY: ii.ddayset, 
-                     MINUTELY: ii.ddayset, 
-                     SECONDLY: ii.ddayset}[freq] 
- 
-        if freq < HOURLY: 
-            timeset = self._timeset 
-        else: 
-            gettimeset = {HOURLY: ii.htimeset, 
-                          MINUTELY: ii.mtimeset, 
-                          SECONDLY: ii.stimeset}[freq] 
-            if ((freq >= HOURLY and 
-                 self._byhour and hour not in self._byhour) or 
-                (freq >= MINUTELY and 
-                 self._byminute and minute not in self._byminute) or 
-                (freq >= SECONDLY and 
-                 self._bysecond and second not in self._bysecond)): 
-                timeset = () 
-            else: 
-                timeset = gettimeset(hour, minute, second) 
- 
-        total = 0 
-        count = self._count 
-        while True: 
-            # Get dayset with the right frequency 
-            dayset, start, end = getdayset(year, month, day) 
- 
-            # Do the "hard" work ;-) 
-            filtered = False 
-            for i in dayset[start:end]: 
-                if ((bymonth and ii.mmask[i] not in bymonth) or 
-                    (byweekno and not ii.wnomask[i]) or 
-                    (byweekday and ii.wdaymask[i] not in byweekday) or 
-                    (ii.nwdaymask and not ii.nwdaymask[i]) or 
-                    (byeaster and not ii.eastermask[i]) or 
-                    ((bymonthday or bynmonthday) and 
-                     ii.mdaymask[i] not in bymonthday and 
-                     ii.nmdaymask[i] not in bynmonthday) or 
-                    (byyearday and 
-                     ((i < ii.yearlen and i+1 not in byyearday and 
-                       -ii.yearlen+i not in byyearday) or 
-                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and 
-                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))): 
-                    dayset[i] = None 
-                    filtered = True 
- 
-            # Output results 
-            if bysetpos and timeset: 
-                poslist = [] 
-                for pos in bysetpos: 
-                    if pos < 0: 
-                        daypos, timepos = divmod(pos, len(timeset)) 
-                    else: 
-                        daypos, timepos = divmod(pos-1, len(timeset)) 
-                    try: 
-                        i = [x for x in dayset[start:end] 
-                             if x is not None][daypos] 
-                        time = timeset[timepos] 
-                    except IndexError: 
-                        pass 
-                    else: 
-                        date = datetime.date.fromordinal(ii.yearordinal+i) 
-                        res = datetime.datetime.combine(date, time) 
-                        if res not in poslist: 
-                            poslist.append(res) 
-                poslist.sort() 
-                for res in poslist: 
-                    if until and res > until: 
-                        self._len = total 
-                        return 
-                    elif res >= self._dtstart: 
+    def _iter(self):
+        year, month, day, hour, minute, second, weekday, yearday, _ = \
+            self._dtstart.timetuple()
+
+        # Some local variables to speed things up a bit
+        freq = self._freq
+        interval = self._interval
+        wkst = self._wkst
+        until = self._until
+        bymonth = self._bymonth
+        byweekno = self._byweekno
+        byyearday = self._byyearday
+        byweekday = self._byweekday
+        byeaster = self._byeaster
+        bymonthday = self._bymonthday
+        bynmonthday = self._bynmonthday
+        bysetpos = self._bysetpos
+        byhour = self._byhour
+        byminute = self._byminute
+        bysecond = self._bysecond
+
+        ii = _iterinfo(self)
+        ii.rebuild(year, month)
+
+        getdayset = {YEARLY: ii.ydayset,
+                     MONTHLY: ii.mdayset,
+                     WEEKLY: ii.wdayset,
+                     DAILY: ii.ddayset,
+                     HOURLY: ii.ddayset,
+                     MINUTELY: ii.ddayset,
+                     SECONDLY: ii.ddayset}[freq]
+
+        if freq < HOURLY:
+            timeset = self._timeset
+        else:
+            gettimeset = {HOURLY: ii.htimeset,
+                          MINUTELY: ii.mtimeset,
+                          SECONDLY: ii.stimeset}[freq]
+            if ((freq >= HOURLY and
+                 self._byhour and hour not in self._byhour) or
+                (freq >= MINUTELY and
+                 self._byminute and minute not in self._byminute) or
+                (freq >= SECONDLY and
+                 self._bysecond and second not in self._bysecond)):
+                timeset = ()
+            else:
+                timeset = gettimeset(hour, minute, second)
+
+        total = 0
+        count = self._count
+        while True:
+            # Get dayset with the right frequency
+            dayset, start, end = getdayset(year, month, day)
+
+            # Do the "hard" work ;-)
+            filtered = False
+            for i in dayset[start:end]:
+                if ((bymonth and ii.mmask[i] not in bymonth) or
+                    (byweekno and not ii.wnomask[i]) or
+                    (byweekday and ii.wdaymask[i] not in byweekday) or
+                    (ii.nwdaymask and not ii.nwdaymask[i]) or
+                    (byeaster and not ii.eastermask[i]) or
+                    ((bymonthday or bynmonthday) and
+                     ii.mdaymask[i] not in bymonthday and
+                     ii.nmdaymask[i] not in bynmonthday) or
+                    (byyearday and
+                     ((i < ii.yearlen and i+1 not in byyearday and
+                       -ii.yearlen+i not in byyearday) or
+                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
+                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
+                    dayset[i] = None
+                    filtered = True
+
+            # Output results
+            if bysetpos and timeset:
+                poslist = []
+                for pos in bysetpos:
+                    if pos < 0:
+                        daypos, timepos = divmod(pos, len(timeset))
+                    else:
+                        daypos, timepos = divmod(pos-1, len(timeset))
+                    try:
+                        i = [x for x in dayset[start:end]
+                             if x is not None][daypos]
+                        time = timeset[timepos]
+                    except IndexError:
+                        pass
+                    else:
+                        date = datetime.date.fromordinal(ii.yearordinal+i)
+                        res = datetime.datetime.combine(date, time)
+                        if res not in poslist:
+                            poslist.append(res)
+                poslist.sort()
+                for res in poslist:
+                    if until and res > until:
+                        self._len = total
+                        return
+                    elif res >= self._dtstart:
                         if count is not None:
-                            count -= 1 
+                            count -= 1
                             if count < 0:
-                                self._len = total 
-                                return 
+                                self._len = total
+                                return
                         total += 1
                         yield res
-            else: 
-                for i in dayset[start:end]: 
-                    if i is not None: 
+            else:
+                for i in dayset[start:end]:
+                    if i is not None:
                         date = datetime.date.fromordinal(ii.yearordinal + i)
-                        for time in timeset: 
-                            res = datetime.datetime.combine(date, time) 
-                            if until and res > until: 
-                                self._len = total 
-                                return 
-                            elif res >= self._dtstart: 
+                        for time in timeset:
+                            res = datetime.datetime.combine(date, time)
+                            if until and res > until:
+                                self._len = total
+                                return
+                            elif res >= self._dtstart:
                                 if count is not None:
-                                    count -= 1 
+                                    count -= 1
                                     if count < 0:
-                                        self._len = total 
-                                        return 
- 
+                                        self._len = total
+                                        return
+
                                 total += 1
                                 yield res
 
-            # Handle frequency and interval 
-            fixday = False 
-            if freq == YEARLY: 
-                year += interval 
-                if year > datetime.MAXYEAR: 
-                    self._len = total 
-                    return 
-                ii.rebuild(year, month) 
-            elif freq == MONTHLY: 
-                month += interval 
-                if month > 12: 
-                    div, mod = divmod(month, 12) 
-                    month = mod 
-                    year += div 
-                    if month == 0: 
-                        month = 12 
-                        year -= 1 
-                    if year > datetime.MAXYEAR: 
-                        self._len = total 
-                        return 
-                ii.rebuild(year, month) 
-            elif freq == WEEKLY: 
-                if wkst > weekday: 
-                    day += -(weekday+1+(6-wkst))+self._interval*7 
-                else: 
-                    day += -(weekday-wkst)+self._interval*7 
-                weekday = wkst 
-                fixday = True 
-            elif freq == DAILY: 
-                day += interval 
-                fixday = True 
-            elif freq == HOURLY: 
-                if filtered: 
-                    # Jump to one iteration before next day 
-                    hour += ((23-hour)//interval)*interval 
+            # Handle frequency and interval
+            fixday = False
+            if freq == YEARLY:
+                year += interval
+                if year > datetime.MAXYEAR:
+                    self._len = total
+                    return
+                ii.rebuild(year, month)
+            elif freq == MONTHLY:
+                month += interval
+                if month > 12:
+                    div, mod = divmod(month, 12)
+                    month = mod
+                    year += div
+                    if month == 0:
+                        month = 12
+                        year -= 1
+                    if year > datetime.MAXYEAR:
+                        self._len = total
+                        return
+                ii.rebuild(year, month)
+            elif freq == WEEKLY:
+                if wkst > weekday:
+                    day += -(weekday+1+(6-wkst))+self._interval*7
+                else:
+                    day += -(weekday-wkst)+self._interval*7
+                weekday = wkst
+                fixday = True
+            elif freq == DAILY:
+                day += interval
+                fixday = True
+            elif freq == HOURLY:
+                if filtered:
+                    # Jump to one iteration before next day
+                    hour += ((23-hour)//interval)*interval
 
                 if byhour:
                     ndays, hour = self.__mod_distance(value=hour,
@@ -962,23 +962,23 @@ class rrule(rrulebase):
                         nhours, minute = divmod(minute+interval, 60)
 
                     div, hour = divmod(hour+nhours, 24)
-                    if div: 
-                        day += div 
-                        fixday = True 
+                    if div:
+                        day += div
+                        fixday = True
                         filtered = False
 
-                    if not byhour or hour in byhour: 
+                    if not byhour or hour in byhour:
                         valid = True
-                        break 
+                        break
 
                 if not valid:
                     raise ValueError('Invalid combination of interval and ' +
                                      'byhour resulting in empty rule.')
 
-                timeset = gettimeset(hour, minute, second) 
+                timeset = gettimeset(hour, minute, second)
             elif freq == SECONDLY:
-                if filtered: 
-                    # Jump to one iteration before next day 
+                if filtered:
+                    # Jump to one iteration before next day
                     second += (((86399 - (hour * 3600 + minute * 60 + second))
                                 // interval) * interval)
 
@@ -994,47 +994,47 @@ class rrule(rrulebase):
                         nminutes, second = divmod(second+interval, 60)
 
                     div, minute = divmod(minute+nminutes, 60)
-                    if div: 
-                        hour += div 
+                    if div:
+                        hour += div
                         div, hour = divmod(hour, 24)
-                        if div: 
-                            day += div 
-                            fixday = True 
+                        if div:
+                            day += div
+                            fixday = True
 
-                    if ((not byhour or hour in byhour) and 
-                            (not byminute or minute in byminute) and 
-                            (not bysecond or second in bysecond)): 
+                    if ((not byhour or hour in byhour) and
+                            (not byminute or minute in byminute) and
+                            (not bysecond or second in bysecond)):
                         valid = True
-                        break 
+                        break
 
                 if not valid:
                     raise ValueError('Invalid combination of interval, ' +
                                      'byhour and byminute resulting in empty' +
                                      ' rule.')
 
-                timeset = gettimeset(hour, minute, second) 
- 
-            if fixday and day > 28: 
-                daysinmonth = calendar.monthrange(year, month)[1] 
-                if day > daysinmonth: 
-                    while day > daysinmonth: 
-                        day -= daysinmonth 
-                        month += 1 
-                        if month == 13: 
-                            month = 1 
-                            year += 1 
-                            if year > datetime.MAXYEAR: 
-                                self._len = total 
-                                return 
-                        daysinmonth = calendar.monthrange(year, month)[1] 
-                    ii.rebuild(year, month) 
- 
+                timeset = gettimeset(hour, minute, second)
+
+            if fixday and day > 28:
+                daysinmonth = calendar.monthrange(year, month)[1]
+                if day > daysinmonth:
+                    while day > daysinmonth:
+                        day -= daysinmonth
+                        month += 1
+                        if month == 13:
+                            month = 1
+                            year += 1
+                            if year > datetime.MAXYEAR:
+                                self._len = total
+                                return
+                        daysinmonth = calendar.monthrange(year, month)[1]
+                    ii.rebuild(year, month)
+
     def __construct_byset(self, start, byxxx, base):
         """
         If a `BYXXX` sequence is passed to the constructor at the same level as
         `FREQ` (e.g. `FREQ=HOURLY,BYHOUR={2,4,7},INTERVAL=3`), there are some
         specifications which cannot be reached given some starting conditions.
- 
+
         This occurs whenever the interval is not coprime with the base of a
         given unit and the difference between the starting position and the
         ending position is not coprime with the greatest common denominator
@@ -1109,316 +1109,316 @@ class rrule(rrulebase):
                 return (accumulator, value)
 
 
-class _iterinfo(object): 
-    __slots__ = ["rrule", "lastyear", "lastmonth", 
-                 "yearlen", "nextyearlen", "yearordinal", "yearweekday", 
-                 "mmask", "mrange", "mdaymask", "nmdaymask", 
-                 "wdaymask", "wnomask", "nwdaymask", "eastermask"] 
- 
-    def __init__(self, rrule): 
-        for attr in self.__slots__: 
-            setattr(self, attr, None) 
-        self.rrule = rrule 
- 
-    def rebuild(self, year, month): 
-        # Every mask is 7 days longer to handle cross-year weekly periods. 
-        rr = self.rrule 
-        if year != self.lastyear: 
+class _iterinfo(object):
+    __slots__ = ["rrule", "lastyear", "lastmonth",
+                 "yearlen", "nextyearlen", "yearordinal", "yearweekday",
+                 "mmask", "mrange", "mdaymask", "nmdaymask",
+                 "wdaymask", "wnomask", "nwdaymask", "eastermask"]
+
+    def __init__(self, rrule):
+        for attr in self.__slots__:
+            setattr(self, attr, None)
+        self.rrule = rrule
+
+    def rebuild(self, year, month):
+        # Every mask is 7 days longer to handle cross-year weekly periods.
+        rr = self.rrule
+        if year != self.lastyear:
             self.yearlen = 365 + calendar.isleap(year)
             self.nextyearlen = 365 + calendar.isleap(year + 1)
-            firstyday = datetime.date(year, 1, 1) 
-            self.yearordinal = firstyday.toordinal() 
-            self.yearweekday = firstyday.weekday() 
- 
-            wday = datetime.date(year, 1, 1).weekday() 
-            if self.yearlen == 365: 
-                self.mmask = M365MASK 
-                self.mdaymask = MDAY365MASK 
-                self.nmdaymask = NMDAY365MASK 
-                self.wdaymask = WDAYMASK[wday:] 
-                self.mrange = M365RANGE 
-            else: 
-                self.mmask = M366MASK 
-                self.mdaymask = MDAY366MASK 
-                self.nmdaymask = NMDAY366MASK 
-                self.wdaymask = WDAYMASK[wday:] 
-                self.mrange = M366RANGE 
- 
-            if not rr._byweekno: 
-                self.wnomask = None 
-            else: 
-                self.wnomask = [0]*(self.yearlen+7) 
-                # no1wkst = firstwkst = self.wdaymask.index(rr._wkst) 
-                no1wkst = firstwkst = (7-self.yearweekday+rr._wkst) % 7 
-                if no1wkst >= 4: 
-                    no1wkst = 0 
-                    # Number of days in the year, plus the days we got 
-                    # from last year. 
-                    wyearlen = self.yearlen+(self.yearweekday-rr._wkst) % 7 
-                else: 
-                    # Number of days in the year, minus the days we 
-                    # left in last year. 
-                    wyearlen = self.yearlen-no1wkst 
-                div, mod = divmod(wyearlen, 7) 
-                numweeks = div+mod//4 
-                for n in rr._byweekno: 
-                    if n < 0: 
-                        n += numweeks+1 
-                    if not (0 < n <= numweeks): 
-                        continue 
-                    if n > 1: 
-                        i = no1wkst+(n-1)*7 
-                        if no1wkst != firstwkst: 
-                            i -= 7-firstwkst 
-                    else: 
-                        i = no1wkst 
-                    for j in range(7): 
-                        self.wnomask[i] = 1 
-                        i += 1 
-                        if self.wdaymask[i] == rr._wkst: 
-                            break 
-                if 1 in rr._byweekno: 
-                    # Check week number 1 of next year as well 
-                    # TODO: Check -numweeks for next year. 
-                    i = no1wkst+numweeks*7 
-                    if no1wkst != firstwkst: 
-                        i -= 7-firstwkst 
-                    if i < self.yearlen: 
-                        # If week starts in next year, we 
-                        # don't care about it. 
-                        for j in range(7): 
-                            self.wnomask[i] = 1 
-                            i += 1 
-                            if self.wdaymask[i] == rr._wkst: 
-                                break 
-                if no1wkst: 
-                    # Check last week number of last year as 
-                    # well. If no1wkst is 0, either the year 
-                    # started on week start, or week number 1 
-                    # got days from last year, so there are no 
-                    # days from last year's last week number in 
-                    # this year. 
-                    if -1 not in rr._byweekno: 
-                        lyearweekday = datetime.date(year-1, 1, 1).weekday() 
-                        lno1wkst = (7-lyearweekday+rr._wkst) % 7 
-                        lyearlen = 365+calendar.isleap(year-1) 
-                        if lno1wkst >= 4: 
-                            lno1wkst = 0 
-                            lnumweeks = 52+(lyearlen + 
-                                            (lyearweekday-rr._wkst) % 7) % 7//4 
-                        else: 
-                            lnumweeks = 52+(self.yearlen-no1wkst) % 7//4 
-                    else: 
-                        lnumweeks = -1 
-                    if lnumweeks in rr._byweekno: 
-                        for i in range(no1wkst): 
-                            self.wnomask[i] = 1 
- 
-        if (rr._bynweekday and (month != self.lastmonth or 
-                                year != self.lastyear)): 
-            ranges = [] 
-            if rr._freq == YEARLY: 
-                if rr._bymonth: 
-                    for month in rr._bymonth: 
-                        ranges.append(self.mrange[month-1:month+1]) 
-                else: 
-                    ranges = [(0, self.yearlen)] 
-            elif rr._freq == MONTHLY: 
-                ranges = [self.mrange[month-1:month+1]] 
-            if ranges: 
-                # Weekly frequency won't get here, so we may not 
-                # care about cross-year weekly periods. 
-                self.nwdaymask = [0]*self.yearlen 
-                for first, last in ranges: 
-                    last -= 1 
-                    for wday, n in rr._bynweekday: 
-                        if n < 0: 
-                            i = last+(n+1)*7 
-                            i -= (self.wdaymask[i]-wday) % 7 
-                        else: 
-                            i = first+(n-1)*7 
-                            i += (7-self.wdaymask[i]+wday) % 7 
-                        if first <= i <= last: 
-                            self.nwdaymask[i] = 1 
- 
-        if rr._byeaster: 
-            self.eastermask = [0]*(self.yearlen+7) 
-            eyday = easter.easter(year).toordinal()-self.yearordinal 
-            for offset in rr._byeaster: 
-                self.eastermask[eyday+offset] = 1 
- 
-        self.lastyear = year 
-        self.lastmonth = month 
- 
-    def ydayset(self, year, month, day): 
-        return list(range(self.yearlen)), 0, self.yearlen 
- 
-    def mdayset(self, year, month, day): 
+            firstyday = datetime.date(year, 1, 1)
+            self.yearordinal = firstyday.toordinal()
+            self.yearweekday = firstyday.weekday()
+
+            wday = datetime.date(year, 1, 1).weekday()
+            if self.yearlen == 365:
+                self.mmask = M365MASK
+                self.mdaymask = MDAY365MASK
+                self.nmdaymask = NMDAY365MASK
+                self.wdaymask = WDAYMASK[wday:]
+                self.mrange = M365RANGE
+            else:
+                self.mmask = M366MASK
+                self.mdaymask = MDAY366MASK
+                self.nmdaymask = NMDAY366MASK
+                self.wdaymask = WDAYMASK[wday:]
+                self.mrange = M366RANGE
+
+            if not rr._byweekno:
+                self.wnomask = None
+            else:
+                self.wnomask = [0]*(self.yearlen+7)
+                # no1wkst = firstwkst = self.wdaymask.index(rr._wkst)
+                no1wkst = firstwkst = (7-self.yearweekday+rr._wkst) % 7
+                if no1wkst >= 4:
+                    no1wkst = 0
+                    # Number of days in the year, plus the days we got
+                    # from last year.
+                    wyearlen = self.yearlen+(self.yearweekday-rr._wkst) % 7
+                else:
+                    # Number of days in the year, minus the days we
+                    # left in last year.
+                    wyearlen = self.yearlen-no1wkst
+                div, mod = divmod(wyearlen, 7)
+                numweeks = div+mod//4
+                for n in rr._byweekno:
+                    if n < 0:
+                        n += numweeks+1
+                    if not (0 < n <= numweeks):
+                        continue
+                    if n > 1:
+                        i = no1wkst+(n-1)*7
+                        if no1wkst != firstwkst:
+                            i -= 7-firstwkst
+                    else:
+                        i = no1wkst
+                    for j in range(7):
+                        self.wnomask[i] = 1
+                        i += 1
+                        if self.wdaymask[i] == rr._wkst:
+                            break
+                if 1 in rr._byweekno:
+                    # Check week number 1 of next year as well
+                    # TODO: Check -numweeks for next year.
+                    i = no1wkst+numweeks*7
+                    if no1wkst != firstwkst:
+                        i -= 7-firstwkst
+                    if i < self.yearlen:
+                        # If week starts in next year, we
+                        # don't care about it.
+                        for j in range(7):
+                            self.wnomask[i] = 1
+                            i += 1
+                            if self.wdaymask[i] == rr._wkst:
+                                break
+                if no1wkst:
+                    # Check last week number of last year as
+                    # well. If no1wkst is 0, either the year
+                    # started on week start, or week number 1
+                    # got days from last year, so there are no
+                    # days from last year's last week number in
+                    # this year.
+                    if -1 not in rr._byweekno:
+                        lyearweekday = datetime.date(year-1, 1, 1).weekday()
+                        lno1wkst = (7-lyearweekday+rr._wkst) % 7
+                        lyearlen = 365+calendar.isleap(year-1)
+                        if lno1wkst >= 4:
+                            lno1wkst = 0
+                            lnumweeks = 52+(lyearlen +
+                                            (lyearweekday-rr._wkst) % 7) % 7//4
+                        else:
+                            lnumweeks = 52+(self.yearlen-no1wkst) % 7//4
+                    else:
+                        lnumweeks = -1
+                    if lnumweeks in rr._byweekno:
+                        for i in range(no1wkst):
+                            self.wnomask[i] = 1
+
+        if (rr._bynweekday and (month != self.lastmonth or
+                                year != self.lastyear)):
+            ranges = []
+            if rr._freq == YEARLY:
+                if rr._bymonth:
+                    for month in rr._bymonth:
+                        ranges.append(self.mrange[month-1:month+1])
+                else:
+                    ranges = [(0, self.yearlen)]
+            elif rr._freq == MONTHLY:
+                ranges = [self.mrange[month-1:month+1]]
+            if ranges:
+                # Weekly frequency won't get here, so we may not
+                # care about cross-year weekly periods.
+                self.nwdaymask = [0]*self.yearlen
+                for first, last in ranges:
+                    last -= 1
+                    for wday, n in rr._bynweekday:
+                        if n < 0:
+                            i = last+(n+1)*7
+                            i -= (self.wdaymask[i]-wday) % 7
+                        else:
+                            i = first+(n-1)*7
+                            i += (7-self.wdaymask[i]+wday) % 7
+                        if first <= i <= last:
+                            self.nwdaymask[i] = 1
+
+        if rr._byeaster:
+            self.eastermask = [0]*(self.yearlen+7)
+            eyday = easter.easter(year).toordinal()-self.yearordinal
+            for offset in rr._byeaster:
+                self.eastermask[eyday+offset] = 1
+
+        self.lastyear = year
+        self.lastmonth = month
+
+    def ydayset(self, year, month, day):
+        return list(range(self.yearlen)), 0, self.yearlen
+
+    def mdayset(self, year, month, day):
         dset = [None]*self.yearlen
-        start, end = self.mrange[month-1:month+1] 
-        for i in range(start, end): 
+        start, end = self.mrange[month-1:month+1]
+        for i in range(start, end):
             dset[i] = i
         return dset, start, end
- 
-    def wdayset(self, year, month, day): 
-        # We need to handle cross-year weeks here. 
+
+    def wdayset(self, year, month, day):
+        # We need to handle cross-year weeks here.
         dset = [None]*(self.yearlen+7)
-        i = datetime.date(year, month, day).toordinal()-self.yearordinal 
-        start = i 
-        for j in range(7): 
+        i = datetime.date(year, month, day).toordinal()-self.yearordinal
+        start = i
+        for j in range(7):
             dset[i] = i
-            i += 1 
-            # if (not (0 <= i < self.yearlen) or 
-            #    self.wdaymask[i] == self.rrule._wkst): 
-            # This will cross the year boundary, if necessary. 
-            if self.wdaymask[i] == self.rrule._wkst: 
-                break 
+            i += 1
+            # if (not (0 <= i < self.yearlen) or
+            #    self.wdaymask[i] == self.rrule._wkst):
+            # This will cross the year boundary, if necessary.
+            if self.wdaymask[i] == self.rrule._wkst:
+                break
         return dset, start, i
- 
-    def ddayset(self, year, month, day): 
+
+    def ddayset(self, year, month, day):
         dset = [None] * self.yearlen
         i = datetime.date(year, month, day).toordinal() - self.yearordinal
         dset[i] = i
         return dset, i, i + 1
- 
-    def htimeset(self, hour, minute, second): 
+
+    def htimeset(self, hour, minute, second):
         tset = []
-        rr = self.rrule 
-        for minute in rr._byminute: 
-            for second in rr._bysecond: 
+        rr = self.rrule
+        for minute in rr._byminute:
+            for second in rr._bysecond:
                 tset.append(datetime.time(hour, minute, second,
                                           tzinfo=rr._tzinfo))
         tset.sort()
         return tset
- 
-    def mtimeset(self, hour, minute, second): 
+
+    def mtimeset(self, hour, minute, second):
         tset = []
-        rr = self.rrule 
-        for second in rr._bysecond: 
+        rr = self.rrule
+        for second in rr._bysecond:
             tset.append(datetime.time(hour, minute, second, tzinfo=rr._tzinfo))
         tset.sort()
         return tset
- 
-    def stimeset(self, hour, minute, second): 
-        return (datetime.time(hour, minute, second, 
-                tzinfo=self.rrule._tzinfo),) 
- 
- 
-class rruleset(rrulebase): 
-    """ The rruleset type allows more complex recurrence setups, mixing 
-    multiple rules, dates, exclusion rules, and exclusion dates. The type 
-    constructor takes the following keyword arguments: 
- 
-    :param cache: If True, caching of results will be enabled, improving 
-                  performance of multiple queries considerably. """ 
- 
-    class _genitem(object): 
-        def __init__(self, genlist, gen): 
-            try: 
-                self.dt = advance_iterator(gen) 
-                genlist.append(self) 
-            except StopIteration: 
-                pass 
-            self.genlist = genlist 
-            self.gen = gen 
- 
-        def __next__(self): 
-            try: 
-                self.dt = advance_iterator(self.gen) 
-            except StopIteration: 
+
+    def stimeset(self, hour, minute, second):
+        return (datetime.time(hour, minute, second,
+                tzinfo=self.rrule._tzinfo),)
+
+
+class rruleset(rrulebase):
+    """ The rruleset type allows more complex recurrence setups, mixing
+    multiple rules, dates, exclusion rules, and exclusion dates. The type
+    constructor takes the following keyword arguments:
+
+    :param cache: If True, caching of results will be enabled, improving
+                  performance of multiple queries considerably. """
+
+    class _genitem(object):
+        def __init__(self, genlist, gen):
+            try:
+                self.dt = advance_iterator(gen)
+                genlist.append(self)
+            except StopIteration:
+                pass
+            self.genlist = genlist
+            self.gen = gen
+
+        def __next__(self):
+            try:
+                self.dt = advance_iterator(self.gen)
+            except StopIteration:
                 if self.genlist[0] is self:
                     heapq.heappop(self.genlist)
                 else:
                     self.genlist.remove(self)
                     heapq.heapify(self.genlist)
- 
-        next = __next__ 
- 
-        def __lt__(self, other): 
-            return self.dt < other.dt 
- 
-        def __gt__(self, other): 
-            return self.dt > other.dt 
- 
-        def __eq__(self, other): 
-            return self.dt == other.dt 
- 
-        def __ne__(self, other): 
-            return self.dt != other.dt 
- 
-    def __init__(self, cache=False): 
-        super(rruleset, self).__init__(cache) 
-        self._rrule = [] 
-        self._rdate = [] 
-        self._exrule = [] 
-        self._exdate = [] 
- 
+
+        next = __next__
+
+        def __lt__(self, other):
+            return self.dt < other.dt
+
+        def __gt__(self, other):
+            return self.dt > other.dt
+
+        def __eq__(self, other):
+            return self.dt == other.dt
+
+        def __ne__(self, other):
+            return self.dt != other.dt
+
+    def __init__(self, cache=False):
+        super(rruleset, self).__init__(cache)
+        self._rrule = []
+        self._rdate = []
+        self._exrule = []
+        self._exdate = []
+
     @_invalidates_cache
-    def rrule(self, rrule): 
-        """ Include the given :py:class:`rrule` instance in the recurrence set 
-            generation. """ 
-        self._rrule.append(rrule) 
- 
+    def rrule(self, rrule):
+        """ Include the given :py:class:`rrule` instance in the recurrence set
+            generation. """
+        self._rrule.append(rrule)
+
     @_invalidates_cache
-    def rdate(self, rdate): 
-        """ Include the given :py:class:`datetime` instance in the recurrence 
-            set generation. """ 
-        self._rdate.append(rdate) 
- 
+    def rdate(self, rdate):
+        """ Include the given :py:class:`datetime` instance in the recurrence
+            set generation. """
+        self._rdate.append(rdate)
+
     @_invalidates_cache
-    def exrule(self, exrule): 
-        """ Include the given rrule instance in the recurrence set exclusion 
-            list. Dates which are part of the given recurrence rules will not 
-            be generated, even if some inclusive rrule or rdate matches them. 
-        """ 
-        self._exrule.append(exrule) 
- 
+    def exrule(self, exrule):
+        """ Include the given rrule instance in the recurrence set exclusion
+            list. Dates which are part of the given recurrence rules will not
+            be generated, even if some inclusive rrule or rdate matches them.
+        """
+        self._exrule.append(exrule)
+
     @_invalidates_cache
-    def exdate(self, exdate): 
-        """ Include the given datetime instance in the recurrence set 
-            exclusion list. Dates included that way will not be generated, 
-            even if some inclusive rrule or rdate matches them. """ 
-        self._exdate.append(exdate) 
- 
-    def _iter(self): 
-        rlist = [] 
-        self._rdate.sort() 
-        self._genitem(rlist, iter(self._rdate)) 
-        for gen in [iter(x) for x in self._rrule]: 
-            self._genitem(rlist, gen) 
-        exlist = [] 
-        self._exdate.sort() 
-        self._genitem(exlist, iter(self._exdate)) 
-        for gen in [iter(x) for x in self._exrule]: 
-            self._genitem(exlist, gen) 
-        lastdt = None 
-        total = 0 
+    def exdate(self, exdate):
+        """ Include the given datetime instance in the recurrence set
+            exclusion list. Dates included that way will not be generated,
+            even if some inclusive rrule or rdate matches them. """
+        self._exdate.append(exdate)
+
+    def _iter(self):
+        rlist = []
+        self._rdate.sort()
+        self._genitem(rlist, iter(self._rdate))
+        for gen in [iter(x) for x in self._rrule]:
+            self._genitem(rlist, gen)
+        exlist = []
+        self._exdate.sort()
+        self._genitem(exlist, iter(self._exdate))
+        for gen in [iter(x) for x in self._exrule]:
+            self._genitem(exlist, gen)
+        lastdt = None
+        total = 0
         heapq.heapify(rlist)
         heapq.heapify(exlist)
-        while rlist: 
-            ritem = rlist[0] 
-            if not lastdt or lastdt != ritem.dt: 
-                while exlist and exlist[0] < ritem: 
+        while rlist:
+            ritem = rlist[0]
+            if not lastdt or lastdt != ritem.dt:
+                while exlist and exlist[0] < ritem:
                     exitem = exlist[0]
                     advance_iterator(exitem)
                     if exlist and exlist[0] is exitem:
                         heapq.heapreplace(exlist, exitem)
-                if not exlist or ritem != exlist[0]: 
-                    total += 1 
-                    yield ritem.dt 
-                lastdt = ritem.dt 
-            advance_iterator(ritem) 
+                if not exlist or ritem != exlist[0]:
+                    total += 1
+                    yield ritem.dt
+                lastdt = ritem.dt
+            advance_iterator(ritem)
             if rlist and rlist[0] is ritem:
                 heapq.heapreplace(rlist, ritem)
-        self._len = total 
- 
- 
+        self._len = total
+
 
 
-class _rrulestr(object): 
+
+class _rrulestr(object):
     """ Parses a string representation of a recurrence rule or set of
     recurrence rules.
- 
+
     :param s:
         Required, a string defining one or more recurrence rules.
 
@@ -1460,58 +1460,58 @@ class _rrulestr(object):
         :class:`dateutil.rrule.rrule`
     """
 
-    _freq_map = {"YEARLY": YEARLY, 
-                 "MONTHLY": MONTHLY, 
-                 "WEEKLY": WEEKLY, 
-                 "DAILY": DAILY, 
-                 "HOURLY": HOURLY, 
-                 "MINUTELY": MINUTELY, 
-                 "SECONDLY": SECONDLY} 
- 
-    _weekday_map = {"MO": 0, "TU": 1, "WE": 2, "TH": 3, 
-                    "FR": 4, "SA": 5, "SU": 6} 
- 
-    def _handle_int(self, rrkwargs, name, value, **kwargs): 
-        rrkwargs[name.lower()] = int(value) 
- 
-    def _handle_int_list(self, rrkwargs, name, value, **kwargs): 
-        rrkwargs[name.lower()] = [int(x) for x in value.split(',')] 
- 
-    _handle_INTERVAL = _handle_int 
-    _handle_COUNT = _handle_int 
-    _handle_BYSETPOS = _handle_int_list 
-    _handle_BYMONTH = _handle_int_list 
-    _handle_BYMONTHDAY = _handle_int_list 
-    _handle_BYYEARDAY = _handle_int_list 
-    _handle_BYEASTER = _handle_int_list 
-    _handle_BYWEEKNO = _handle_int_list 
-    _handle_BYHOUR = _handle_int_list 
-    _handle_BYMINUTE = _handle_int_list 
-    _handle_BYSECOND = _handle_int_list 
- 
-    def _handle_FREQ(self, rrkwargs, name, value, **kwargs): 
-        rrkwargs["freq"] = self._freq_map[value] 
- 
-    def _handle_UNTIL(self, rrkwargs, name, value, **kwargs): 
-        global parser 
-        if not parser: 
-            from dateutil import parser 
-        try: 
-            rrkwargs["until"] = parser.parse(value, 
-                                             ignoretz=kwargs.get("ignoretz"), 
-                                             tzinfos=kwargs.get("tzinfos")) 
-        except ValueError: 
-            raise ValueError("invalid until date") 
- 
-    def _handle_WKST(self, rrkwargs, name, value, **kwargs): 
-        rrkwargs["wkst"] = self._weekday_map[value] 
- 
+    _freq_map = {"YEARLY": YEARLY,
+                 "MONTHLY": MONTHLY,
+                 "WEEKLY": WEEKLY,
+                 "DAILY": DAILY,
+                 "HOURLY": HOURLY,
+                 "MINUTELY": MINUTELY,
+                 "SECONDLY": SECONDLY}
+
+    _weekday_map = {"MO": 0, "TU": 1, "WE": 2, "TH": 3,
+                    "FR": 4, "SA": 5, "SU": 6}
+
+    def _handle_int(self, rrkwargs, name, value, **kwargs):
+        rrkwargs[name.lower()] = int(value)
+
+    def _handle_int_list(self, rrkwargs, name, value, **kwargs):
+        rrkwargs[name.lower()] = [int(x) for x in value.split(',')]
+
+    _handle_INTERVAL = _handle_int
+    _handle_COUNT = _handle_int
+    _handle_BYSETPOS = _handle_int_list
+    _handle_BYMONTH = _handle_int_list
+    _handle_BYMONTHDAY = _handle_int_list
+    _handle_BYYEARDAY = _handle_int_list
+    _handle_BYEASTER = _handle_int_list
+    _handle_BYWEEKNO = _handle_int_list
+    _handle_BYHOUR = _handle_int_list
+    _handle_BYMINUTE = _handle_int_list
+    _handle_BYSECOND = _handle_int_list
+
+    def _handle_FREQ(self, rrkwargs, name, value, **kwargs):
+        rrkwargs["freq"] = self._freq_map[value]
+
+    def _handle_UNTIL(self, rrkwargs, name, value, **kwargs):
+        global parser
+        if not parser:
+            from dateutil import parser
+        try:
+            rrkwargs["until"] = parser.parse(value,
+                                             ignoretz=kwargs.get("ignoretz"),
+                                             tzinfos=kwargs.get("tzinfos"))
+        except ValueError:
+            raise ValueError("invalid until date")
+
+    def _handle_WKST(self, rrkwargs, name, value, **kwargs):
+        rrkwargs["wkst"] = self._weekday_map[value]
+
     def _handle_BYWEEKDAY(self, rrkwargs, name, value, **kwargs):
         """
         Two ways to specify this: +1MO or MO(+1)
         """
-        l = [] 
-        for wday in value.split(','): 
+        l = []
+        for wday in value.split(','):
             if '(' in wday:
                 # If it's of the form TH(+1), etc.
                 splt = wday.split('(')
@@ -1529,37 +1529,37 @@ class _rrulestr(object):
             else:
                 raise ValueError("Invalid (empty) BYDAY specification.")
 
-            l.append(weekdays[self._weekday_map[w]](n)) 
-        rrkwargs["byweekday"] = l 
- 
-    _handle_BYDAY = _handle_BYWEEKDAY 
- 
-    def _parse_rfc_rrule(self, line, 
-                         dtstart=None, 
-                         cache=False, 
-                         ignoretz=False, 
-                         tzinfos=None): 
-        if line.find(':') != -1: 
-            name, value = line.split(':') 
-            if name != "RRULE": 
-                raise ValueError("unknown parameter name") 
-        else: 
-            value = line 
-        rrkwargs = {} 
-        for pair in value.split(';'): 
-            name, value = pair.split('=') 
-            name = name.upper() 
-            value = value.upper() 
-            try: 
-                getattr(self, "_handle_"+name)(rrkwargs, name, value, 
-                                               ignoretz=ignoretz, 
-                                               tzinfos=tzinfos) 
-            except AttributeError: 
-                raise ValueError("unknown parameter '%s'" % name) 
-            except (KeyError, ValueError): 
-                raise ValueError("invalid '%s': %s" % (name, value)) 
-        return rrule(dtstart=dtstart, cache=cache, **rrkwargs) 
- 
+            l.append(weekdays[self._weekday_map[w]](n))
+        rrkwargs["byweekday"] = l
+
+    _handle_BYDAY = _handle_BYWEEKDAY
+
+    def _parse_rfc_rrule(self, line,
+                         dtstart=None,
+                         cache=False,
+                         ignoretz=False,
+                         tzinfos=None):
+        if line.find(':') != -1:
+            name, value = line.split(':')
+            if name != "RRULE":
+                raise ValueError("unknown parameter name")
+        else:
+            value = line
+        rrkwargs = {}
+        for pair in value.split(';'):
+            name, value = pair.split('=')
+            name = name.upper()
+            value = value.upper()
+            try:
+                getattr(self, "_handle_"+name)(rrkwargs, name, value,
+                                               ignoretz=ignoretz,
+                                               tzinfos=tzinfos)
+            except AttributeError:
+                raise ValueError("unknown parameter '%s'" % name)
+            except (KeyError, ValueError):
+                raise ValueError("invalid '%s': %s" % (name, value))
+        return rrule(dtstart=dtstart, cache=cache, **rrkwargs)
+
     def _parse_date_value(self, date_value, parms, rule_tzids,
                           ignoretz, tzids, tzinfos):
         global parser
@@ -1612,126 +1612,126 @@ class _rrulestr(object):
 
         return datevals
 
-    def _parse_rfc(self, s, 
-                   dtstart=None, 
-                   cache=False, 
-                   unfold=False, 
-                   forceset=False, 
-                   compatible=False, 
-                   ignoretz=False, 
+    def _parse_rfc(self, s,
+                   dtstart=None,
+                   cache=False,
+                   unfold=False,
+                   forceset=False,
+                   compatible=False,
+                   ignoretz=False,
                    tzids=None,
-                   tzinfos=None): 
-        global parser 
-        if compatible: 
-            forceset = True 
-            unfold = True 
+                   tzinfos=None):
+        global parser
+        if compatible:
+            forceset = True
+            unfold = True
 
         TZID_NAMES = dict(map(
             lambda x: (x.upper(), x),
             re.findall('TZID=(?P<name>[^:]+):', s)
         ))
-        s = s.upper() 
-        if not s.strip(): 
-            raise ValueError("empty string") 
-        if unfold: 
-            lines = s.splitlines() 
-            i = 0 
-            while i < len(lines): 
-                line = lines[i].rstrip() 
-                if not line: 
-                    del lines[i] 
-                elif i > 0 and line[0] == " ": 
-                    lines[i-1] += line[1:] 
-                    del lines[i] 
-                else: 
-                    i += 1 
-        else: 
-            lines = s.split() 
-        if (not forceset and len(lines) == 1 and (s.find(':') == -1 or 
-                                                  s.startswith('RRULE:'))): 
-            return self._parse_rfc_rrule(lines[0], cache=cache, 
-                                         dtstart=dtstart, ignoretz=ignoretz, 
-                                         tzinfos=tzinfos) 
-        else: 
-            rrulevals = [] 
-            rdatevals = [] 
-            exrulevals = [] 
-            exdatevals = [] 
-            for line in lines: 
-                if not line: 
-                    continue 
-                if line.find(':') == -1: 
-                    name = "RRULE" 
-                    value = line 
-                else: 
-                    name, value = line.split(':', 1) 
-                parms = name.split(';') 
-                if not parms: 
-                    raise ValueError("empty property name") 
-                name = parms[0] 
-                parms = parms[1:] 
-                if name == "RRULE": 
-                    for parm in parms: 
-                        raise ValueError("unsupported RRULE parm: "+parm) 
-                    rrulevals.append(value) 
-                elif name == "RDATE": 
-                    for parm in parms: 
-                        if parm != "VALUE=DATE-TIME": 
-                            raise ValueError("unsupported RDATE parm: "+parm) 
-                    rdatevals.append(value) 
-                elif name == "EXRULE": 
-                    for parm in parms: 
-                        raise ValueError("unsupported EXRULE parm: "+parm) 
-                    exrulevals.append(value) 
-                elif name == "EXDATE": 
+        s = s.upper()
+        if not s.strip():
+            raise ValueError("empty string")
+        if unfold:
+            lines = s.splitlines()
+            i = 0
+            while i < len(lines):
+                line = lines[i].rstrip()
+                if not line:
+                    del lines[i]
+                elif i > 0 and line[0] == " ":
+                    lines[i-1] += line[1:]
+                    del lines[i]
+                else:
+                    i += 1
+        else:
+            lines = s.split()
+        if (not forceset and len(lines) == 1 and (s.find(':') == -1 or
+                                                  s.startswith('RRULE:'))):
+            return self._parse_rfc_rrule(lines[0], cache=cache,
+                                         dtstart=dtstart, ignoretz=ignoretz,
+                                         tzinfos=tzinfos)
+        else:
+            rrulevals = []
+            rdatevals = []
+            exrulevals = []
+            exdatevals = []
+            for line in lines:
+                if not line:
+                    continue
+                if line.find(':') == -1:
+                    name = "RRULE"
+                    value = line
+                else:
+                    name, value = line.split(':', 1)
+                parms = name.split(';')
+                if not parms:
+                    raise ValueError("empty property name")
+                name = parms[0]
+                parms = parms[1:]
+                if name == "RRULE":
+                    for parm in parms:
+                        raise ValueError("unsupported RRULE parm: "+parm)
+                    rrulevals.append(value)
+                elif name == "RDATE":
+                    for parm in parms:
+                        if parm != "VALUE=DATE-TIME":
+                            raise ValueError("unsupported RDATE parm: "+parm)
+                    rdatevals.append(value)
+                elif name == "EXRULE":
+                    for parm in parms:
+                        raise ValueError("unsupported EXRULE parm: "+parm)
+                    exrulevals.append(value)
+                elif name == "EXDATE":
                     exdatevals.extend(
                         self._parse_date_value(value, parms,
                                                TZID_NAMES, ignoretz,
                                                tzids, tzinfos)
                     )
-                elif name == "DTSTART": 
+                elif name == "DTSTART":
                     dtvals = self._parse_date_value(value, parms, TZID_NAMES,
                                                     ignoretz, tzids, tzinfos)
                     if len(dtvals) != 1:
                         raise ValueError("Multiple DTSTART values specified:" +
                                          value)
                     dtstart = dtvals[0]
-                else: 
-                    raise ValueError("unsupported property: "+name) 
-            if (forceset or len(rrulevals) > 1 or rdatevals 
-                    or exrulevals or exdatevals): 
-                if not parser and (rdatevals or exdatevals): 
-                    from dateutil import parser 
+                else:
+                    raise ValueError("unsupported property: "+name)
+            if (forceset or len(rrulevals) > 1 or rdatevals
+                    or exrulevals or exdatevals):
+                if not parser and (rdatevals or exdatevals):
+                    from dateutil import parser
                 rset = rruleset(cache=cache)
-                for value in rrulevals: 
+                for value in rrulevals:
                     rset.rrule(self._parse_rfc_rrule(value, dtstart=dtstart,
                                                      ignoretz=ignoretz,
                                                      tzinfos=tzinfos))
-                for value in rdatevals: 
-                    for datestr in value.split(','): 
+                for value in rdatevals:
+                    for datestr in value.split(','):
                         rset.rdate(parser.parse(datestr,
                                                 ignoretz=ignoretz,
                                                 tzinfos=tzinfos))
-                for value in exrulevals: 
+                for value in exrulevals:
                     rset.exrule(self._parse_rfc_rrule(value, dtstart=dtstart,
                                                       ignoretz=ignoretz,
                                                       tzinfos=tzinfos))
-                for value in exdatevals: 
+                for value in exdatevals:
                     rset.exdate(value)
-                if compatible and dtstart: 
+                if compatible and dtstart:
                     rset.rdate(dtstart)
                 return rset
-            else: 
-                return self._parse_rfc_rrule(rrulevals[0], 
-                                             dtstart=dtstart, 
-                                             cache=cache, 
-                                             ignoretz=ignoretz, 
-                                             tzinfos=tzinfos) 
- 
-    def __call__(self, s, **kwargs): 
-        return self._parse_rfc(s, **kwargs) 
- 
-
-rrulestr = _rrulestr() 
- 
-# vim:ts=4:sw=4:et 
+            else:
+                return self._parse_rfc_rrule(rrulevals[0],
+                                             dtstart=dtstart,
+                                             cache=cache,
+                                             ignoretz=ignoretz,
+                                             tzinfos=tzinfos)
+
+    def __call__(self, s, **kwargs):
+        return self._parse_rfc(s, **kwargs)
+
+
+rrulestr = _rrulestr()
+
+# vim:ts=4:sw=4:et
diff --git a/contrib/python/dateutil/dateutil/zoneinfo/__init__.py b/contrib/python/dateutil/dateutil/zoneinfo/__init__.py
index 7611a477c2..34f11ad66c 100644
--- a/contrib/python/dateutil/dateutil/zoneinfo/__init__.py
+++ b/contrib/python/dateutil/dateutil/zoneinfo/__init__.py
@@ -1,45 +1,45 @@
-# -*- coding: utf-8 -*- 
-import warnings 
+# -*- coding: utf-8 -*-
+import warnings
 import json
 
-from tarfile import TarFile 
+from tarfile import TarFile
 from pkgutil import get_data
-from io import BytesIO 
- 
+from io import BytesIO
+
 from dateutil.tz import tzfile as _tzfile
- 
+
 __all__ = ["get_zonefile_instance", "gettz", "gettz_db_metadata"]
- 
+
 ZONEFILENAME = "dateutil-zoneinfo.tar.gz"
 METADATA_FN = 'METADATA'
- 
- 
+
+
 class tzfile(_tzfile):
-    def __reduce__(self): 
-        return (gettz, (self._filename,)) 
- 
- 
-def getzoneinfofile_stream(): 
-    try: 
+    def __reduce__(self):
+        return (gettz, (self._filename,))
+
+
+def getzoneinfofile_stream():
+    try:
         return BytesIO(get_data(__name__, ZONEFILENAME))
-    except IOError as e:  # TODO  switch to FileNotFoundError? 
-        warnings.warn("I/O error({0}): {1}".format(e.errno, e.strerror)) 
-        return None 
- 
- 
-class ZoneInfoFile(object): 
-    def __init__(self, zonefile_stream=None): 
-        if zonefile_stream is not None: 
+    except IOError as e:  # TODO  switch to FileNotFoundError?
+        warnings.warn("I/O error({0}): {1}".format(e.errno, e.strerror))
+        return None
+
+
+class ZoneInfoFile(object):
+    def __init__(self, zonefile_stream=None):
+        if zonefile_stream is not None:
             with TarFile.open(fileobj=zonefile_stream) as tf:
                 self.zones = {zf.name: tzfile(tf.extractfile(zf), filename=zf.name)
                               for zf in tf.getmembers()
                               if zf.isfile() and zf.name != METADATA_FN}
-                # deal with links: They'll point to their parent object. Less 
-                # waste of memory 
+                # deal with links: They'll point to their parent object. Less
+                # waste of memory
                 links = {zl.name: self.zones[zl.linkname]
                          for zl in tf.getmembers() if
                          zl.islnk() or zl.issym()}
-                self.zones.update(links) 
+                self.zones.update(links)
                 try:
                     metadata_json = tf.extractfile(tf.getmember(METADATA_FN))
                     metadata_str = metadata_json.read().decode('UTF-8')
@@ -47,15 +47,15 @@ class ZoneInfoFile(object):
                 except KeyError:
                     # no metadata in tar file
                     self.metadata = None
-        else: 
+        else:
             self.zones = {}
             self.metadata = None
- 
+
     def get(self, name, default=None):
         """
         Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method
         for retrieving zones from the zone dictionary.
- 
+
         :param name:
             The name of the zone to retrieve. (Generally IANA zone names)
 
@@ -68,15 +68,15 @@ class ZoneInfoFile(object):
         return self.zones.get(name, default)
 
 
-# The current API has gettz as a module function, although in fact it taps into 
-# a stateful class. So as a workaround for now, without changing the API, we 
-# will create a new "global" class instance the first time a user requests a 
-# timezone. Ugly, but adheres to the api. 
-# 
+# The current API has gettz as a module function, although in fact it taps into
+# a stateful class. So as a workaround for now, without changing the API, we
+# will create a new "global" class instance the first time a user requests a
+# timezone. Ugly, but adheres to the api.
+#
 # TODO: Remove after deprecation period.
 _CLASS_ZONE_INSTANCE = []
- 
- 
+
+
 def get_zonefile_instance(new_instance=False):
     """
     This is a convenience function which provides a :class:`ZoneInfoFile`
@@ -106,7 +106,7 @@ def get_zonefile_instance(new_instance=False):
     return zif
 
 
-def gettz(name): 
+def gettz(name):
     """
     This retrieves a time zone from the local zoneinfo tarball that is packaged
     with dateutil.
@@ -139,23 +139,23 @@ def gettz(name):
                   "instead. See the documentation for details.",
                   DeprecationWarning)
 
-    if len(_CLASS_ZONE_INSTANCE) == 0: 
-        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream())) 
-    return _CLASS_ZONE_INSTANCE[0].zones.get(name) 
- 
- 
+    if len(_CLASS_ZONE_INSTANCE) == 0:
+        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
+    return _CLASS_ZONE_INSTANCE[0].zones.get(name)
+
+
 def gettz_db_metadata():
     """ Get the zonefile metadata
- 
+
     See `zonefile_metadata`_
- 
+
     :returns:
         A dictionary with the database metadata
 
     .. deprecated:: 2.6
         See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
         query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
-    """ 
+    """
     warnings.warn("zoneinfo.gettz_db_metadata() will be removed in future "
                   "versions, to use the dateutil-provided zoneinfo files, "
                   "ZoneInfoFile object and query the 'metadata' attribute "
diff --git a/contrib/python/dateutil/ya.make b/contrib/python/dateutil/ya.make
index 93693341e5..0c4102c505 100644
--- a/contrib/python/dateutil/ya.make
+++ b/contrib/python/dateutil/ya.make
@@ -1,7 +1,7 @@
 # Generated by devtools/yamaker (pypi).
 
 PY23_LIBRARY()
- 
+
 OWNER(g:python-contrib)
 
 VERSION(2.8.2)
@@ -48,7 +48,7 @@ RESOURCE_FILES(
     dateutil/zoneinfo/dateutil-zoneinfo.tar.gz
 )
 
-END() 
+END()
 
 RECURSE_FOR_TESTS(
     tests
diff --git a/contrib/python/six/six.py b/contrib/python/six/six.py
index a47723ca61..4cba03c75f 100644
--- a/contrib/python/six/six.py
+++ b/contrib/python/six/six.py
@@ -1,100 +1,100 @@
 # Copyright (c) 2010-2020 Benjamin Peterson
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy 
-# of this software and associated documentation files (the "Software"), to deal 
-# in the Software without restriction, including without limitation the rights 
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
-# copies of the Software, and to permit persons to whom the Software is 
-# furnished to do so, subject to the following conditions: 
-# 
-# The above copyright notice and this permission notice shall be included in all 
-# copies or substantial portions of the Software. 
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
-# SOFTWARE. 
- 
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
 """Utilities for writing code that runs on Python 2 and 3"""
 
-from __future__ import absolute_import 
- 
-import functools 
+from __future__ import absolute_import
+
+import functools
 import itertools
-import operator 
-import sys 
-import types 
- 
-__author__ = "Benjamin Peterson <benjamin@python.org>" 
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
 __version__ = "1.16.0"
- 
- 
-# Useful for very coarse version differentiation. 
-PY2 = sys.version_info[0] == 2 
-PY3 = sys.version_info[0] == 3 
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
 PY34 = sys.version_info[0:2] >= (3, 4)
- 
-if PY3: 
-    string_types = str, 
-    integer_types = int, 
-    class_types = type, 
-    text_type = str 
-    binary_type = bytes 
- 
-    MAXSIZE = sys.maxsize 
-else: 
-    string_types = basestring, 
-    integer_types = (int, long) 
-    class_types = (type, types.ClassType) 
-    text_type = unicode 
-    binary_type = str 
- 
-    if sys.platform.startswith("java"): 
-        # Jython always uses 32 bits. 
-        MAXSIZE = int((1 << 31) - 1) 
-    else: 
-        # It's possible to have sizeof(long) != sizeof(Py_ssize_t). 
-        class X(object): 
-
-            def __len__(self): 
-                return 1 << 31 
-        try: 
-            len(X()) 
-        except OverflowError: 
-            # 32-bit 
-            MAXSIZE = int((1 << 31) - 1) 
-        else: 
-            # 64-bit 
-            MAXSIZE = int((1 << 63) - 1) 
-        del X 
- 
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
 if PY34:
     from importlib.util import spec_from_loader
 else:
     spec_from_loader = None
- 
-
-def _add_doc(func, doc): 
-    """Add documentation to a function.""" 
-    func.__doc__ = doc 
- 
- 
-def _import_module(name): 
-    """Import module, returning the module after the last dot.""" 
-    __import__(name) 
-    return sys.modules[name] 
- 
- 
-class _LazyDescr(object): 
- 
-    def __init__(self, name): 
-        self.name = name 
- 
-    def __get__(self, obj, tp): 
-        result = self._resolve() 
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
         setattr(obj, self.name, result)  # Invokes __set__.
         try:
             # This is a bit ugly, but it avoids running this again by
@@ -102,559 +102,559 @@ class _LazyDescr(object):
             delattr(obj.__class__, self.name)
         except AttributeError:
             pass
-        return result 
- 
- 
-class MovedModule(_LazyDescr): 
- 
-    def __init__(self, name, old, new=None): 
-        super(MovedModule, self).__init__(name) 
-        if PY3: 
-            if new is None: 
-                new = name 
-            self.mod = new 
-        else: 
-            self.mod = old 
- 
-    def _resolve(self): 
-        return _import_module(self.mod) 
- 
-    def __getattr__(self, attr): 
-        _module = self._resolve() 
-        value = getattr(_module, attr) 
-        setattr(self, attr, value) 
-        return value 
- 
- 
-class _LazyModule(types.ModuleType): 
- 
-    def __init__(self, name): 
-        super(_LazyModule, self).__init__(name) 
-        self.__doc__ = self.__class__.__doc__ 
- 
-    def __dir__(self): 
-        attrs = ["__doc__", "__name__"] 
-        attrs += [attr.name for attr in self._moved_attributes] 
-        return attrs 
- 
-    # Subclasses should override this 
-    _moved_attributes = [] 
- 
- 
-class MovedAttribute(_LazyDescr): 
- 
-    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): 
-        super(MovedAttribute, self).__init__(name) 
-        if PY3: 
-            if new_mod is None: 
-                new_mod = name 
-            self.mod = new_mod 
-            if new_attr is None: 
-                if old_attr is None: 
-                    new_attr = name 
-                else: 
-                    new_attr = old_attr 
-            self.attr = new_attr 
-        else: 
-            self.mod = old_mod 
-            if old_attr is None: 
-                old_attr = name 
-            self.attr = old_attr 
- 
-    def _resolve(self): 
-        module = _import_module(self.mod) 
-        return getattr(module, self.attr) 
- 
- 
-class _SixMetaPathImporter(object): 
-
-    """ 
-    A meta path importer to import six.moves and its submodules. 
- 
-    This class implements a PEP302 finder and loader. It should be compatible 
-    with Python 2.5 and all existing versions of Python3 
-    """ 
-
-    def __init__(self, six_module_name): 
-        self.name = six_module_name 
-        self.known_modules = {} 
- 
-    def _add_module(self, mod, *fullnames): 
-        for fullname in fullnames: 
-            self.known_modules[self.name + "." + fullname] = mod 
- 
-    def _get_module(self, fullname): 
-        return self.known_modules[self.name + "." + fullname] 
- 
-    def find_module(self, fullname, path=None): 
-        if fullname in self.known_modules: 
-            return self 
-        return None 
- 
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
     def find_spec(self, fullname, path, target=None):
         if fullname in self.known_modules:
             return spec_from_loader(fullname, self)
         return None
 
-    def __get_module(self, fullname): 
-        try: 
-            return self.known_modules[fullname] 
-        except KeyError: 
-            raise ImportError("This loader does not know module " + fullname) 
- 
-    def load_module(self, fullname): 
-        try: 
-            # in case of a reload 
-            return sys.modules[fullname] 
-        except KeyError: 
-            pass 
-        mod = self.__get_module(fullname) 
-        if isinstance(mod, MovedModule): 
-            mod = mod._resolve() 
-        else: 
-            mod.__loader__ = self 
-        sys.modules[fullname] = mod 
-        return mod 
- 
-    def is_package(self, fullname): 
-        """ 
-        Return true, if the named module is a package. 
- 
-        We need this method to get correct spec objects with 
-        Python 3.4 (see PEP451) 
-        """ 
-        return hasattr(self.__get_module(fullname), "__path__") 
- 
-    def get_code(self, fullname): 
-        """Return None 
- 
-        Required, if is_package is implemented""" 
-        self.__get_module(fullname)  # eventually raises ImportError 
-        return None 
-    get_source = get_code  # same as get_code 
- 
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
     def create_module(self, spec):
         return self.load_module(spec.name)
 
     def exec_module(self, module):
         pass
 
-_importer = _SixMetaPathImporter(__name__) 
- 
- 
-class _MovedItems(_LazyModule): 
-
-    """Lazy loading of moved objects""" 
-    __path__ = []  # mark as package 
- 
- 
-_moved_attributes = [ 
-    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), 
-    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), 
-    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), 
-    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), 
-    MovedAttribute("intern", "__builtin__", "sys"), 
-    MovedAttribute("map", "itertools", "builtins", "imap", "map"), 
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
     MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
     MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
     MovedAttribute("getoutput", "commands", "subprocess"),
-    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), 
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
     MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
-    MovedAttribute("reduce", "__builtin__", "functools"), 
-    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), 
-    MovedAttribute("StringIO", "StringIO", "io"), 
-    MovedAttribute("UserDict", "UserDict", "collections"), 
-    MovedAttribute("UserList", "UserList", "collections"), 
-    MovedAttribute("UserString", "UserString", "collections"), 
-    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), 
-    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), 
-    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), 
-    MovedModule("builtins", "__builtin__"), 
-    MovedModule("configparser", "ConfigParser"), 
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
     MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
-    MovedModule("copyreg", "copy_reg"), 
-    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), 
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
     # MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
     MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
-    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), 
-    MovedModule("http_cookies", "Cookie", "http.cookies"), 
-    MovedModule("html_entities", "htmlentitydefs", "html.entities"), 
-    MovedModule("html_parser", "HTMLParser", "html.parser"), 
-    MovedModule("http_client", "httplib", "http.client"), 
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
     MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
     MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
-    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), 
-    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), 
-    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), 
-    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), 
-    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), 
-    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), 
-    MovedModule("cPickle", "cPickle", "pickle"), 
-    MovedModule("queue", "Queue"), 
-    MovedModule("reprlib", "repr"), 
-    MovedModule("socketserver", "SocketServer"), 
-    MovedModule("_thread", "thread", "_thread"), 
-    MovedModule("tkinter", "Tkinter"), 
-    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), 
-    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), 
-    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), 
-    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), 
-    MovedModule("tkinter_tix", "Tix", "tkinter.tix"), 
-    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), 
-    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), 
-    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), 
-    MovedModule("tkinter_colorchooser", "tkColorChooser", 
-                "tkinter.colorchooser"), 
-    MovedModule("tkinter_commondialog", "tkCommonDialog", 
-                "tkinter.commondialog"), 
-    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), 
-    MovedModule("tkinter_font", "tkFont", "tkinter.font"), 
-    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), 
-    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", 
-                "tkinter.simpledialog"), 
-    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), 
-    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), 
-    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), 
-    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), 
-    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), 
-    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), 
-] 
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
 # Add windows specific modules.
 if sys.platform == "win32":
     _moved_attributes += [
         MovedModule("winreg", "_winreg"),
     ]
 
-for attr in _moved_attributes: 
-    setattr(_MovedItems, attr.name, attr) 
-    if isinstance(attr, MovedModule): 
-        _importer._add_module(attr, "moves." + attr.name) 
-del attr 
- 
-_MovedItems._moved_attributes = _moved_attributes 
- 
-moves = _MovedItems(__name__ + ".moves") 
-_importer._add_module(moves, "moves") 
- 
- 
-class Module_six_moves_urllib_parse(_LazyModule): 
-
-    """Lazy loading of moved objects in six.moves.urllib_parse""" 
- 
- 
-_urllib_parse_moved_attributes = [ 
-    MovedAttribute("ParseResult", "urlparse", "urllib.parse"), 
-    MovedAttribute("SplitResult", "urlparse", "urllib.parse"), 
-    MovedAttribute("parse_qs", "urlparse", "urllib.parse"), 
-    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), 
-    MovedAttribute("urldefrag", "urlparse", "urllib.parse"), 
-    MovedAttribute("urljoin", "urlparse", "urllib.parse"), 
-    MovedAttribute("urlparse", "urlparse", "urllib.parse"), 
-    MovedAttribute("urlsplit", "urlparse", "urllib.parse"), 
-    MovedAttribute("urlunparse", "urlparse", "urllib.parse"), 
-    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), 
-    MovedAttribute("quote", "urllib", "urllib.parse"), 
-    MovedAttribute("quote_plus", "urllib", "urllib.parse"), 
-    MovedAttribute("unquote", "urllib", "urllib.parse"), 
-    MovedAttribute("unquote_plus", "urllib", "urllib.parse"), 
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
     MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
-    MovedAttribute("urlencode", "urllib", "urllib.parse"), 
-    MovedAttribute("splitquery", "urllib", "urllib.parse"), 
-    MovedAttribute("splittag", "urllib", "urllib.parse"), 
-    MovedAttribute("splituser", "urllib", "urllib.parse"), 
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
     MovedAttribute("splitvalue", "urllib", "urllib.parse"),
-    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), 
-    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), 
-    MovedAttribute("uses_params", "urlparse", "urllib.parse"), 
-    MovedAttribute("uses_query", "urlparse", "urllib.parse"), 
-    MovedAttribute("uses_relative", "urlparse", "urllib.parse"), 
-] 
-for attr in _urllib_parse_moved_attributes: 
-    setattr(Module_six_moves_urllib_parse, attr.name, attr) 
-del attr 
- 
-Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes 
- 
-_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), 
-                      "moves.urllib_parse", "moves.urllib.parse") 
- 
- 
-class Module_six_moves_urllib_error(_LazyModule): 
-
-    """Lazy loading of moved objects in six.moves.urllib_error""" 
- 
- 
-_urllib_error_moved_attributes = [ 
-    MovedAttribute("URLError", "urllib2", "urllib.error"), 
-    MovedAttribute("HTTPError", "urllib2", "urllib.error"), 
-    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), 
-] 
-for attr in _urllib_error_moved_attributes: 
-    setattr(Module_six_moves_urllib_error, attr.name, attr) 
-del attr 
- 
-Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes 
- 
-_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), 
-                      "moves.urllib_error", "moves.urllib.error") 
- 
- 
-class Module_six_moves_urllib_request(_LazyModule): 
-
-    """Lazy loading of moved objects in six.moves.urllib_request""" 
- 
- 
-_urllib_request_moved_attributes = [ 
-    MovedAttribute("urlopen", "urllib2", "urllib.request"), 
-    MovedAttribute("install_opener", "urllib2", "urllib.request"), 
-    MovedAttribute("build_opener", "urllib2", "urllib.request"), 
-    MovedAttribute("pathname2url", "urllib", "urllib.request"), 
-    MovedAttribute("url2pathname", "urllib", "urllib.request"), 
-    MovedAttribute("getproxies", "urllib", "urllib.request"), 
-    MovedAttribute("Request", "urllib2", "urllib.request"), 
-    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), 
-    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("BaseHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), 
-    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("FileHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("FTPHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), 
-    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), 
-    MovedAttribute("urlretrieve", "urllib", "urllib.request"), 
-    MovedAttribute("urlcleanup", "urllib", "urllib.request"), 
-    MovedAttribute("URLopener", "urllib", "urllib.request"), 
-    MovedAttribute("FancyURLopener", "urllib", "urllib.request"), 
-    MovedAttribute("proxy_bypass", "urllib", "urllib.request"), 
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
     MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
     MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
-] 
-for attr in _urllib_request_moved_attributes: 
-    setattr(Module_six_moves_urllib_request, attr.name, attr) 
-del attr 
- 
-Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes 
- 
-_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), 
-                      "moves.urllib_request", "moves.urllib.request") 
- 
- 
-class Module_six_moves_urllib_response(_LazyModule): 
-
-    """Lazy loading of moved objects in six.moves.urllib_response""" 
- 
- 
-_urllib_response_moved_attributes = [ 
-    MovedAttribute("addbase", "urllib", "urllib.response"), 
-    MovedAttribute("addclosehook", "urllib", "urllib.response"), 
-    MovedAttribute("addinfo", "urllib", "urllib.response"), 
-    MovedAttribute("addinfourl", "urllib", "urllib.response"), 
-] 
-for attr in _urllib_response_moved_attributes: 
-    setattr(Module_six_moves_urllib_response, attr.name, attr) 
-del attr 
- 
-Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes 
- 
-_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), 
-                      "moves.urllib_response", "moves.urllib.response") 
- 
- 
-class Module_six_moves_urllib_robotparser(_LazyModule): 
-
-    """Lazy loading of moved objects in six.moves.urllib_robotparser""" 
- 
- 
-_urllib_robotparser_moved_attributes = [ 
-    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), 
-] 
-for attr in _urllib_robotparser_moved_attributes: 
-    setattr(Module_six_moves_urllib_robotparser, attr.name, attr) 
-del attr 
- 
-Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes 
- 
-_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), 
-                      "moves.urllib_robotparser", "moves.urllib.robotparser") 
- 
- 
-class Module_six_moves_urllib(types.ModuleType): 
-
-    """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" 
-    __path__ = []  # mark as package 
-    parse = _importer._get_module("moves.urllib_parse") 
-    error = _importer._get_module("moves.urllib_error") 
-    request = _importer._get_module("moves.urllib_request") 
-    response = _importer._get_module("moves.urllib_response") 
-    robotparser = _importer._get_module("moves.urllib_robotparser") 
- 
-    def __dir__(self): 
-        return ['parse', 'error', 'request', 'response', 'robotparser'] 
- 
-_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), 
-                      "moves.urllib") 
- 
- 
-def add_move(move): 
-    """Add an item to six.moves.""" 
-    setattr(_MovedItems, move.name, move) 
- 
- 
-def remove_move(name): 
-    """Remove item from six.moves.""" 
-    try: 
-        delattr(_MovedItems, name) 
-    except AttributeError: 
-        try: 
-            del moves.__dict__[name] 
-        except KeyError: 
-            raise AttributeError("no such move, %r" % (name,)) 
- 
- 
-if PY3: 
-    _meth_func = "__func__" 
-    _meth_self = "__self__" 
- 
-    _func_closure = "__closure__" 
-    _func_code = "__code__" 
-    _func_defaults = "__defaults__" 
-    _func_globals = "__globals__" 
-else: 
-    _meth_func = "im_func" 
-    _meth_self = "im_self" 
- 
-    _func_closure = "func_closure" 
-    _func_code = "func_code" 
-    _func_defaults = "func_defaults" 
-    _func_globals = "func_globals" 
- 
- 
-try: 
-    advance_iterator = next 
-except NameError: 
-    def advance_iterator(it): 
-        return it.next() 
-next = advance_iterator 
- 
- 
-try: 
-    callable = callable 
-except NameError: 
-    def callable(obj): 
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) 
- 
- 
-if PY3: 
-    def get_unbound_function(unbound): 
-        return unbound 
- 
-    create_bound_method = types.MethodType 
- 
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
     def create_unbound_method(func, cls):
         return func
 
-    Iterator = object 
-else: 
-    def get_unbound_function(unbound): 
-        return unbound.im_func 
- 
-    def create_bound_method(func, obj): 
-        return types.MethodType(func, obj, obj.__class__) 
- 
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
     def create_unbound_method(func, cls):
         return types.MethodType(func, None, cls)
 
-    class Iterator(object): 
- 
-        def next(self): 
-            return type(self).__next__(self) 
- 
-    callable = callable 
-_add_doc(get_unbound_function, 
-         """Get the function out of a possibly unbound function""") 
- 
- 
-get_method_function = operator.attrgetter(_meth_func) 
-get_method_self = operator.attrgetter(_meth_self) 
-get_function_closure = operator.attrgetter(_func_closure) 
-get_function_code = operator.attrgetter(_func_code) 
-get_function_defaults = operator.attrgetter(_func_defaults) 
-get_function_globals = operator.attrgetter(_func_globals) 
- 
- 
-if PY3: 
-    def iterkeys(d, **kw): 
-        return iter(d.keys(**kw)) 
- 
-    def itervalues(d, **kw): 
-        return iter(d.values(**kw)) 
- 
-    def iteritems(d, **kw): 
-        return iter(d.items(**kw)) 
- 
-    def iterlists(d, **kw): 
-        return iter(d.lists(**kw)) 
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
 
     viewkeys = operator.methodcaller("keys")
 
     viewvalues = operator.methodcaller("values")
 
     viewitems = operator.methodcaller("items")
-else: 
-    def iterkeys(d, **kw): 
+else:
+    def iterkeys(d, **kw):
         return d.iterkeys(**kw)
- 
-    def itervalues(d, **kw): 
+
+    def itervalues(d, **kw):
         return d.itervalues(**kw)
- 
-    def iteritems(d, **kw): 
+
+    def iteritems(d, **kw):
         return d.iteritems(**kw)
- 
-    def iterlists(d, **kw): 
+
+    def iterlists(d, **kw):
         return d.iterlists(**kw)
- 
+
     viewkeys = operator.methodcaller("viewkeys")
 
     viewvalues = operator.methodcaller("viewvalues")
 
     viewitems = operator.methodcaller("viewitems")
 
-_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") 
-_add_doc(itervalues, "Return an iterator over the values of a dictionary.") 
-_add_doc(iteritems, 
-         "Return an iterator over the (key, value) pairs of a dictionary.") 
-_add_doc(iterlists, 
-         "Return an iterator over the (key, [values]) pairs of a dictionary.") 
- 
- 
-if PY3: 
-    def b(s): 
-        return s.encode("latin-1") 
-
-    def u(s): 
-        return s 
-    unichr = chr 
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
     import struct
     int2byte = struct.Struct(">B").pack
     del struct
-    byte2int = operator.itemgetter(0) 
-    indexbytes = operator.getitem 
-    iterbytes = iter 
-    import io 
-    StringIO = io.StringIO 
-    BytesIO = io.BytesIO 
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
     del io
     _assertCountEqual = "assertCountEqual"
     if sys.version_info[1] <= 1:
@@ -665,32 +665,32 @@ if PY3:
         _assertRaisesRegex = "assertRaisesRegex"
         _assertRegex = "assertRegex"
         _assertNotRegex = "assertNotRegex"
-else: 
-    def b(s): 
-        return s 
-    # Workaround for standalone backslash 
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
 
-    def u(s): 
-        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape") 
-    unichr = unichr 
-    int2byte = chr 
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
 
-    def byte2int(bs): 
-        return ord(bs[0]) 
+    def byte2int(bs):
+        return ord(bs[0])
 
-    def indexbytes(buf, i): 
-        return ord(buf[i]) 
+    def indexbytes(buf, i):
+        return ord(buf[i])
     iterbytes = functools.partial(itertools.imap, ord)
-    import StringIO 
-    StringIO = BytesIO = StringIO.StringIO 
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
     _assertCountEqual = "assertItemsEqual"
     _assertRaisesRegex = "assertRaisesRegexp"
     _assertRegex = "assertRegexpMatches"
     _assertNotRegex = "assertNotRegexpMatches"
-_add_doc(b, """Byte literal""") 
-_add_doc(u, """Text literal""") 
- 
- 
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
 def assertCountEqual(self, *args, **kwargs):
     return getattr(self, _assertCountEqual)(*args, **kwargs)
 
@@ -707,10 +707,10 @@ def assertNotRegex(self, *args, **kwargs):
     return getattr(self, _assertNotRegex)(*args, **kwargs)
 
 
-if PY3: 
-    exec_ = getattr(moves.builtins, "exec") 
- 
-    def reraise(tp, value, tb=None): 
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
         try:
             if value is None:
                 value = tp()
@@ -720,28 +720,28 @@ if PY3:
         finally:
             value = None
             tb = None
- 
-else: 
-    def exec_(_code_, _globs_=None, _locs_=None): 
-        """Execute code in a namespace.""" 
-        if _globs_ is None: 
-            frame = sys._getframe(1) 
-            _globs_ = frame.f_globals 
-            if _locs_ is None: 
-                _locs_ = frame.f_locals 
-            del frame 
-        elif _locs_ is None: 
-            _locs_ = _globs_ 
-        exec("""exec _code_ in _globs_, _locs_""") 
- 
-    exec_("""def reraise(tp, value, tb=None): 
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
     try:
         raise tp, value, tb
     finally:
         tb = None
-""") 
- 
- 
+""")
+
+
 if sys.version_info[:2] > (3,):
     exec_("""def raise_from(value, from_value):
     try:
@@ -754,64 +754,64 @@ else:
         raise value
 
 
-print_ = getattr(moves.builtins, "print", None) 
-if print_ is None: 
-    def print_(*args, **kwargs): 
-        """The new-style print function for Python 2.4 and 2.5.""" 
-        fp = kwargs.pop("file", sys.stdout) 
-        if fp is None: 
-            return 
-
-        def write(data): 
-            if not isinstance(data, basestring): 
-                data = str(data) 
-            # If the file has an encoding, encode unicode with it. 
-            if (isinstance(fp, file) and 
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
                     isinstance(data, unicode) and
                     fp.encoding is not None):
-                errors = getattr(fp, "errors", None) 
-                if errors is None: 
-                    errors = "strict" 
-                data = data.encode(fp.encoding, errors) 
-            fp.write(data) 
-        want_unicode = False 
-        sep = kwargs.pop("sep", None) 
-        if sep is not None: 
-            if isinstance(sep, unicode): 
-                want_unicode = True 
-            elif not isinstance(sep, str): 
-                raise TypeError("sep must be None or a string") 
-        end = kwargs.pop("end", None) 
-        if end is not None: 
-            if isinstance(end, unicode): 
-                want_unicode = True 
-            elif not isinstance(end, str): 
-                raise TypeError("end must be None or a string") 
-        if kwargs: 
-            raise TypeError("invalid keyword arguments to print()") 
-        if not want_unicode: 
-            for arg in args: 
-                if isinstance(arg, unicode): 
-                    want_unicode = True 
-                    break 
-        if want_unicode: 
-            newline = unicode("\n") 
-            space = unicode(" ") 
-        else: 
-            newline = "\n" 
-            space = " " 
-        if sep is None: 
-            sep = space 
-        if end is None: 
-            end = newline 
-        for i, arg in enumerate(args): 
-            if i: 
-                write(sep) 
-            write(arg) 
-        write(end) 
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
 if sys.version_info[:2] < (3, 3):
     _print = print_
- 
+
     def print_(*args, **kwargs):
         fp = kwargs.get("file", sys.stdout)
         flush = kwargs.pop("flush", False)
@@ -819,9 +819,9 @@ if sys.version_info[:2] < (3, 3):
         if flush and fp is not None:
             fp.flush()
 
-_add_doc(reraise, """Reraise an exception.""") 
- 
-if sys.version_info[0:2] < (3, 4): 
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
     # This does exactly the same what the :func:`py3:functools.update_wrapper`
     # function does on Python versions after 3.2. It sets the ``__wrapped__``
     # attribute on ``wrapper`` object and it doesn't raise an error if any of
@@ -843,24 +843,24 @@ if sys.version_info[0:2] < (3, 4):
         return wrapper
     _update_wrapper.__doc__ = functools.update_wrapper.__doc__
 
-    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, 
-              updated=functools.WRAPPER_UPDATES): 
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
         return functools.partial(_update_wrapper, wrapped=wrapped,
                                  assigned=assigned, updated=updated)
     wraps.__doc__ = functools.wraps.__doc__
 
-else: 
-    wraps = functools.wraps 
- 
+else:
+    wraps = functools.wraps
+
 
-def with_metaclass(meta, *bases): 
-    """Create a base class with a metaclass.""" 
-    # This requires a bit of explanation: the basic idea is to make a dummy 
-    # metaclass for one level of class instantiation that replaces itself with 
-    # the actual metaclass. 
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
     class metaclass(type):
 
-        def __new__(cls, name, this_bases, d): 
+        def __new__(cls, name, this_bases, d):
             if sys.version_info[:2] >= (3, 7):
                 # This version introduced PEP 560 that requires a bit
                 # of extra care (we mimic what is done by __build_class__).
@@ -874,26 +874,26 @@ def with_metaclass(meta, *bases):
         @classmethod
         def __prepare__(cls, name, this_bases):
             return meta.__prepare__(name, bases)
-    return type.__new__(metaclass, 'temporary_class', (), {}) 
- 
- 
-def add_metaclass(metaclass): 
-    """Class decorator for creating a class with a metaclass.""" 
-    def wrapper(cls): 
-        orig_vars = cls.__dict__.copy() 
-        slots = orig_vars.get('__slots__') 
-        if slots is not None: 
-            if isinstance(slots, str): 
-                slots = [slots] 
-            for slots_var in slots: 
-                orig_vars.pop(slots_var) 
-        orig_vars.pop('__dict__', None) 
-        orig_vars.pop('__weakref__', None) 
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
         if hasattr(cls, '__qualname__'):
             orig_vars['__qualname__'] = cls.__qualname__
-        return metaclass(cls.__name__, cls.__bases__, orig_vars) 
-    return wrapper 
- 
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
 
 def ensure_binary(s, encoding='utf-8', errors='strict'):
     """Coerce **s** to six.binary_type.
@@ -973,26 +973,26 @@ def python_2_unicode_compatible(klass):
     return klass
 
 
-# Complete the moves implementation. 
-# This code is at the end of this module to speed up module loading. 
-# Turn this module into a package. 
-__path__ = []  # required for PEP 302 and PEP 451 
-__package__ = __name__  # see PEP 366 @ReservedAssignment 
-if globals().get("__spec__") is not None: 
-    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable 
-# Remove other six meta path importers, since they cause problems. This can 
-# happen if six is removed from sys.modules and then reloaded. (Setuptools does 
-# this for some reason.) 
-if sys.meta_path: 
-    for i, importer in enumerate(sys.meta_path): 
-        # Here's some real nastiness: Another "instance" of the six module might 
-        # be floating around. Therefore, we can't use isinstance() to check for 
-        # the six meta path importer, since the other six instance will have 
-        # inserted an importer with different class. 
-        if (type(importer).__name__ == "_SixMetaPathImporter" and 
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
                 importer.name == __name__):
-            del sys.meta_path[i] 
-            break 
-    del i, importer 
-# Finally, add the importer to the meta path import hook. 
-sys.meta_path.append(_importer) 
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/contrib/python/six/ya.make b/contrib/python/six/ya.make
index ac79d83d1b..e0c7849214 100644
--- a/contrib/python/six/ya.make
+++ b/contrib/python/six/ya.make
@@ -19,7 +19,7 @@ RESOURCE_FILES(
 
 NO_LINT()
 
-END() 
+END()
 
 RECURSE_FOR_TESTS(
     tests