|
# -*- 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 dateutil._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(year=until.year, month=until.month, day=until.day, tzinfo=self._tzinfo) |
|
if until: |
|
until = until.replace(tzinfo=self._tzinfo) |
|
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 |
Thank you very much! The patch is not anymore necessary.