Remove windows python distribution from repo and add requirements.txt

1 files changed, 0 insertions, 1610 deletions

diff --git a/python/dateutil/rrule.py b/python/dateutil/rrule.py
deleted file mode 100644
index 429f8fc..0000000
--- a/python/dateutil/rrule.py
+++ /dev/null
@@ -1,1610 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-The rrule module offers a small, complete, and very fast, implementation of
-the recurrence rules documented in the
-`iCalendar RFC <http://www.ietf.org/rfc/rfc2445.txt>`_,
-including support for caching of results.
-"""
-import itertools
-import datetime
-import calendar
-import sys
-
-try:
-    from math import gcd
-except ImportError:
-    from fractions import gcd
-
-from six import advance_iterator, integer_types
-from six.moves import _thread, range
-import heapq
-
-from ._common import weekday as weekdaybase
-
-# For warning about deprecation of until and count
-from warnings import warn
-
-__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
-
-
-class weekday(weekdaybase):
-    """
-    This version of weekday does not allow n = 0.
-    """
-    def __init__(self, wkday, n=None):
-        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
-    cached length.
-    """
-    def inner_func(self, *args, **kwargs):
-        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()
-            self._invalidate_cache()
-        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 _invalidate_cache(self):
-        if self._cache is not None:
-            self._cache = []
-            self._cache_complete = False
-            self._cache_gen = self._iter()
-
-            if self._cache_lock.locked():
-                self._cache_lock.release()
-
-        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
-
-    # __len__() introduces a large performance penality.
-    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
-        datetime instance, equivalent to `after`.
-
-        :param dt:
-            The datetime at which to start generating recurrences.
-
-        :param count:
-            The maximum number of recurrences to generate. If `None` (default),
-            dates are generated until the recurrence rule is exhausted.
-
-        :param inc:
-            If `dt` is an instance of the rule and `inc` is `True`, it is
-            included in the output.
-
-        :yields: Yields a sequence of `datetime` objects.
-        """
-
-        if self._cache_complete:
-            gen = self._cache
-        else:
-            gen = self
-
-        # Select the comparison function
-        if inc:
-            comp = lambda dc, dtc: dc >= dtc
-        else:
-            comp = lambda dc, dtc: dc > dtc
-
-        # Generate dates
-        n = 0
-        for d in gen:
-            if comp(d, dt):
-                if count is not None:
-                    n += 1
-                    if n > count:
-                        break
-
-                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.
-
-    .. note::
-        Per RFC section 3.3.10, recurrence instances falling on invalid dates
-        and times are ignored rather than coerced:
-
-            Recurrence rules may generate recurrence instances with an invalid
-            date (e.g., February 30) or nonexistent local time (e.g., 1:30 AM
-            on a day where the local time is moved forward by an hour at 1:00
-            AM).  Such recurrence instances MUST be ignored and MUST NOT be
-            counted as part of the recurrence set.
-
-        This can lead to possibly surprising behavior when, for example, the
-        start date occurs at the end of the month:
-
-        >>> from dateutil.rrule import rrule, MONTHLY
-        >>> from datetime import datetime
-        >>> start_date = datetime(2014, 12, 31)
-        >>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))
-        ... # doctest: +NORMALIZE_WHITESPACE
-        [datetime.datetime(2014, 12, 31, 0, 0),
-         datetime.datetime(2015, 1, 31, 0, 0),
-         datetime.datetime(2015, 3, 31, 0, 0),
-         datetime.datetime(2015, 5, 31, 0, 0)]
-
-    Additionally, it supports the following keyword arguments:
-
-    :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.
-    :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:
-        How many occurrences will be generated.
-
-        .. note::
-            As of version 2.5.0, the use of the ``until`` keyword together
-            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
-    :param until:
-        If given, this must be a datetime instance, that will specify the
-        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
-        ``until`` parameter.
-
-        .. note::
-            As of version 2.5.0, the use of the ``until`` keyword together
-            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
-    :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 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 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.
-     """
-    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:
-            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
-
-        # Cache the original byxxx rules, if they are provided, as the _byxxx
-        # attributes do not necessarily map to the inputs, and this can be
-        # a problem in generating the strings. Only store things if they've
-        # 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 count is not None and until:
-            warn("Using both 'count' and 'until' is inconsistent with RFC 2445"
-                 " 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 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 bymonth is None:
-                    bymonth = dtstart.month
-                    self._original_rule['bymonth'] = None
-                bymonthday = dtstart.day
-                self._original_rule['bymonthday'] = None
-            elif freq == MONTHLY:
-                bymonthday = dtstart.day
-                self._original_rule['bymonthday'] = None
-            elif freq == WEEKLY:
-                byweekday = dtstart.weekday()
-                self._original_rule['byweekday'] = None
-
-        # bymonth
-        if bymonth is None:
-            self._bymonth = None
-        else:
-            if isinstance(bymonth, integer_types):
-                bymonth = (bymonth,)
-
-            self._bymonth = tuple(sorted(set(bymonth)))
-
-            if 'bymonth' not in self._original_rule:
-                self._original_rule['bymonth'] = self._bymonth
-
-        # byyearday
-        if byyearday is None:
-            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:
-                self._byeaster = tuple(sorted(byeaster))
-
-            self._original_rule['byeaster'] = self._byeaster
-        else:
-            self._byeaster = None
-
-        # bymonthday
-        if bymonthday is None:
-            self._bymonthday = ()
-            self._bynmonthday = ()
-        else:
-            if isinstance(bymonthday, integer_types):
-                bymonthday = (bymonthday,)
-
-            bymonthday = set(bymonthday)            # Ensure it's unique
-
-            self._bymonthday = tuple(sorted(x for x in bymonthday if x > 0))
-            self._bynmonthday = tuple(sorted(x for x in bymonthday if x < 0))
-
-            # Storing positive numbers first, then negative numbers
-            if 'bymonthday' not in self._original_rule:
-                self._original_rule['bymonthday'] = tuple(
-                    itertools.chain(self._bymonthday, self._bynmonthday))
-
-        # byweekno
-        if byweekno is None:
-            self._byweekno = None
-        else:
-            if isinstance(byweekno, integer_types):
-                byweekno = (byweekno,)
-
-            self._byweekno = tuple(sorted(set(byweekno)))
-
-            self._original_rule['byweekno'] = self._byweekno
-
-        # 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.
-            if isinstance(byweekday, integer_types) or hasattr(byweekday, "n"):
-                byweekday = (byweekday,)
-
-            self._byweekday = set()
-            self._bynweekday = set()
-            for wday in byweekday:
-                if isinstance(wday, integer_types):
-                    self._byweekday.add(wday)
-                elif not wday.n or freq > MONTHLY:
-                    self._byweekday.add(wday.weekday)
-                else:
-                    self._bynweekday.add((wday.weekday, wday.n))
-
-            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))
-                orig_byweekday = [weekday(x) for x in self._byweekday]
-            else:
-                orig_byweekday = tuple()
-
-            if self._bynweekday is not None:
-                self._bynweekday = tuple(sorted(self._bynweekday))
-                orig_bynweekday = [weekday(*x) for x in self._bynweekday]
-            else:
-                orig_bynweekday = tuple()
-
-            if 'byweekday' not in self._original_rule:
-                self._original_rule['byweekday'] = tuple(itertools.chain(
-                    orig_byweekday, orig_bynweekday))
-
-        # byhour
-        if byhour is None:
-            if freq < HOURLY:
-                self._byhour = set((dtstart.hour,))
-            else:
-                self._byhour = None
-        else:
-            if isinstance(byhour, integer_types):
-                byhour = (byhour,)
-
-            if freq == HOURLY:
-                self._byhour = self.__construct_byset(start=dtstart.hour,
-                                                      byxxx=byhour,
-                                                      base=24)
-            else:
-                self._byhour = set(byhour)
-
-            self._byhour = tuple(sorted(self._byhour))
-            self._original_rule['byhour'] = self._byhour
-
-        # byminute
-        if byminute is None:
-            if freq < MINUTELY:
-                self._byminute = set((dtstart.minute,))
-            else:
-                self._byminute = None
-        else:
-            if isinstance(byminute, integer_types):
-                byminute = (byminute,)
-
-            if freq == MINUTELY:
-                self._byminute = self.__construct_byset(start=dtstart.minute,
-                                                        byxxx=byminute,
-                                                        base=60)
-            else:
-                self._byminute = set(byminute)
-
-            self._byminute = tuple(sorted(self._byminute))
-            self._original_rule['byminute'] = self._byminute
-
-        # bysecond
-        if bysecond is None:
-            if freq < SECONDLY:
-                self._bysecond = ((dtstart.second,))
-            else:
-                self._bysecond = None
-        else:
-            if isinstance(bysecond, integer_types):
-                bysecond = (bysecond,)
-
-            self._bysecond = set(bysecond)
-
-            if freq == SECONDLY:
-                self._bysecond = self.__construct_byset(start=dtstart.second,
-                                                        byxxx=bysecond,
-                                                        base=60)
-            else:
-                self._bysecond = set(bysecond)
-
-            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)
-
-    def __str__(self):
-        """
-        Output a string that would generate this RRULE if passed to rrulestr.
-        This is mostly compatible with RFC2445, except for the
-        dateutil-specific extension BYEASTER.
-        """
-
-        output = []
-        h, m, s = [None] * 3
-        if self._dtstart:
-            output.append(self._dtstart.strftime('DTSTART:%Y%m%dT%H%M%S'))
-            h, m, s = self._dtstart.timetuple()[3:6]
-
-        parts = ['FREQ=' + FREQNAMES[self._freq]]
-        if self._interval != 1:
-            parts.append('INTERVAL=' + str(self._interval))
-
-        if self._wkst:
-            parts.append('WKST=' + repr(weekday(self._wkst))[0:2])
-
-        if self._count is not None:
-            parts.append('COUNT=' + str(self._count))
-
-        if self._until:
-            parts.append(self._until.strftime('UNTIL=%Y%m%dT%H%M%S'))
-
-        if self._original_rule.get('byweekday') is not None:
-            # The str() method on weekday objects doesn't generate
-            # RFC2445-compliant strings, so we should modify that.
-            original_rule = dict(self._original_rule)
-            wday_strings = []
-            for wday in original_rule['byweekday']:
-                if wday.n:
-                    wday_strings.append('{n:+d}{wday}'.format(
-                        n=wday.n,
-                        wday=repr(wday)[0:2]))
-                else:
-                    wday_strings.append(repr(wday))
-
-            original_rule['byweekday'] = wday_strings
-        else:
-            original_rule = self._original_rule
-
-        partfmt = '{name}={vals}'
-        for name, key in [('BYSETPOS', 'bysetpos'),
-                          ('BYMONTH', 'bymonth'),
-                          ('BYMONTHDAY', 'bymonthday'),
-                          ('BYYEARDAY', 'byyearday'),
-                          ('BYWEEKNO', 'byweekno'),
-                          ('BYDAY', 'byweekday'),
-                          ('BYHOUR', 'byhour'),
-                          ('BYMINUTE', 'byminute'),
-                          ('BYSECOND', 'bysecond'),
-                          ('BYEASTER', 'byeaster')]:
-            value = original_rule.get(key)
-            if value:
-                parts.append(partfmt.format(name=name, vals=(','.join(str(v)
-                                                             for v in value))))
-
-        output.append(';'.join(parts))
-        return '\n'.join(output)
-
-    def replace(self, **kwargs):
-        """Return new rrule with same attributes except for those attributes given new
-           values by whichever keyword arguments are specified."""
-        new_kwargs = {"interval": self._interval,
-                      "count": self._count,
-                      "dtstart": self._dtstart,
-                      "freq": self._freq,
-                      "until": self._until,
-                      "wkst": self._wkst,
-                      "cache": False if self._cache is None else True }
-        new_kwargs.update(self._original_rule)
-        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:
-                        if count is not None:
-                            count -= 1
-                            if count < 0:
-                                self._len = total
-                                return
-                        total += 1
-                        yield res
-            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:
-                                if count is not None:
-                                    count -= 1
-                                    if count < 0:
-                                        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
-
-                if byhour:
-                    ndays, hour = self.__mod_distance(value=hour,
-                                                      byxxx=self._byhour,
-                                                      base=24)
-                else:
-                    ndays, hour = divmod(hour+interval, 24)
-
-                if ndays:
-                    day += ndays
-                    fixday = True
-
-                timeset = gettimeset(hour, minute, second)
-            elif freq == MINUTELY:
-                if filtered:
-                    # Jump to one iteration before next day
-                    minute += ((1439-(hour*60+minute))//interval)*interval
-
-                valid = False
-                rep_rate = (24*60)
-                for j in range(rep_rate // gcd(interval, rep_rate)):
-                    if byminute:
-                        nhours, minute = \
-                            self.__mod_distance(value=minute,
-                                                byxxx=self._byminute,
-                                                base=60)
-                    else:
-                        nhours, minute = divmod(minute+interval, 60)
-
-                    div, hour = divmod(hour+nhours, 24)
-                    if div:
-                        day += div
-                        fixday = True
-                        filtered = False
-
-                    if not byhour or hour in byhour:
-                        valid = True
-                        break
-
-                if not valid:
-                    raise ValueError('Invalid combination of interval and ' +
-                                     'byhour resulting in empty rule.')
-
-                timeset = gettimeset(hour, minute, second)
-            elif freq == SECONDLY:
-                if filtered:
-                    # Jump to one iteration before next day
-                    second += (((86399 - (hour * 3600 + minute * 60 + second))
-                                // interval) * interval)
-
-                rep_rate = (24 * 3600)
-                valid = False
-                for j in range(0, rep_rate // gcd(interval, rep_rate)):
-                    if bysecond:
-                        nminutes, second = \
-                            self.__mod_distance(value=second,
-                                                byxxx=self._bysecond,
-                                                base=60)
-                    else:
-                        nminutes, second = divmod(second+interval, 60)
-
-                    div, minute = divmod(minute+nminutes, 60)
-                    if div:
-                        hour += div
-                        div, hour = divmod(hour, 24)
-                        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)):
-                        valid = True
-                        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)
-
-    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
-        between the interval and the base. For example, with a FREQ of hourly
-        starting at 17:00 and an interval of 4, the only valid values for
-        BYHOUR would be {21, 1, 5, 9, 13, 17}, because 4 and 24 are not
-        coprime.
-
-        :param start:
-            Specifies the starting position.
-        :param byxxx:
-            An iterable containing the list of allowed values.
-        :param base:
-            The largest allowable value for the specified frequency (e.g.
-            24 hours, 60 minutes).
-
-        This does not preserve the type of the iterable, returning a set, since
-        the values should be unique and the order is irrelevant, this will
-        speed up later lookups.
-
-        In the event of an empty set, raises a :exception:`ValueError`, as this
-        results in an empty rrule.
-        """
-
-        cset = set()
-
-        # Support a single byxxx value.
-        if isinstance(byxxx, integer_types):
-            byxxx = (byxxx, )
-
-        for num in byxxx:
-            i_gcd = gcd(self._interval, base)
-            # Use divmod rather than % because we need to wrap negative nums.
-            if i_gcd == 1 or divmod(num - start, i_gcd)[1] == 0:
-                cset.add(num)
-
-        if len(cset) == 0:
-            raise ValueError("Invalid rrule byxxx generates an empty set.")
-
-        return cset
-
-    def __mod_distance(self, value, byxxx, base):
-        """
-        Calculates the next value in a sequence where the `FREQ` parameter is
-        specified along with a `BYXXX` parameter at the same "level"
-        (e.g. `HOURLY` specified with `BYHOUR`).
-
-        :param value:
-            The old value of the component.
-        :param byxxx:
-            The `BYXXX` set, which should have been generated by
-            `rrule._construct_byset`, or something else which checks that a
-            valid rule is present.
-        :param base:
-            The largest allowable value for the specified frequency (e.g.
-            24 hours, 60 minutes).
-
-        If a valid value is not found after `base` iterations (the maximum
-        number before the sequence would start to repeat), this raises a
-        :exception:`ValueError`, as no valid values were found.
-
-        This returns a tuple of `divmod(n*interval, base)`, where `n` is the
-        smallest number of `interval` repetitions until the next specified
-        value in `byxxx` is found.
-        """
-        accumulator = 0
-        for ii in range(1, base + 1):
-            # Using divmod() over % to account for negative intervals
-            div, value = divmod(value + self._interval, base)
-            accumulator += div
-            if value in byxxx:
-                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:
-            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):
-        dset = [None]*self.yearlen
-        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.
-        dset = [None]*(self.yearlen+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
-        return dset, start, i
-
-    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):
-        tset = []
-        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):
-        tset = []
-        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:
-                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 = []
-
-    @_invalidates_cache
-    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)
-
-    @_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)
-
-    @_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
-        heapq.heapify(rlist)
-        heapq.heapify(exlist)
-        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 rlist and rlist[0] is ritem:
-                heapq.heapreplace(rlist, ritem)
-        self._len = total
-
-
-class _rrulestr(object):
-
-    _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(','):
-            if '(' in wday:
-                # If it's of the form TH(+1), etc.
-                splt = wday.split('(')
-                w = splt[0]
-                n = int(splt[1][:-1])
-            elif len(wday):
-                # If it's of the form +1MO
-                for i in range(len(wday)):
-                    if wday[i] not in '+-0123456789':
-                        break
-                n = wday[:i] or None
-                w = wday[i:]
-                if n:
-                    n = int(n)
-            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)
-
-    def _parse_rfc(self, s,
-                   dtstart=None,
-                   cache=False,
-                   unfold=False,
-                   forceset=False,
-                   compatible=False,
-                   ignoretz=False,
-                   tzinfos=None):
-        global parser
-        if compatible:
-            forceset = True
-            unfold = True
-        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":
-                    for parm in parms:
-                        if parm != "VALUE=DATE-TIME":
-                            raise ValueError("unsupported EXDATE parm: "+parm)
-                    exdatevals.append(value)
-                elif name == "DTSTART":
-                    for parm in parms:
-                        raise ValueError("unsupported DTSTART parm: "+parm)
-                    if not parser:
-                        from dateutil import parser
-                    dtstart = parser.parse(value, ignoretz=ignoretz,
-                                           tzinfos=tzinfos)
-                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:
-                    rset.rrule(self._parse_rfc_rrule(value, dtstart=dtstart,
-                                                     ignoretz=ignoretz,
-                                                     tzinfos=tzinfos))
-                for value in rdatevals:
-                    for datestr in value.split(','):
-                        rset.rdate(parser.parse(datestr,
-                                                ignoretz=ignoretz,
-                                                tzinfos=tzinfos))
-                for value in exrulevals:
-                    rset.exrule(self._parse_rfc_rrule(value, dtstart=dtstart,
-                                                      ignoretz=ignoretz,
-                                                      tzinfos=tzinfos))
-                for value in exdatevals:
-                    for datestr in value.split(','):
-                        rset.exdate(parser.parse(datestr,
-                                                 ignoretz=ignoretz,
-                                                 tzinfos=tzinfos))
-                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