def get_current_event(content: str, include_all_day: bool):
now = datetime.now().astimezone()
events = icalparser.parse_events(content=content)
if events is None:
return None
temp_event = None
for event in events:
if event.all_day and not include_all_day:
continue
else:
event.start = event.start.astimezone()
event.end = event.end.astimezone()
if (event.end >= now) and (
temp_event is None or event.start < temp_event.start
):
temp_event = event
if temp_event is None:
return None
return {
"summary": temp_event.summary,
"start": parser_icalevents.get_hass_date(
temp_event.start, temp_event.all_day
),
"end": parser_icalevents.get_hass_date(temp_event.end, temp_event.all_day),
"location": temp_event.location,
"description": temp_event.description,
}
def get_event_list(content: str, start, end, include_all_day: bool):
event_list = []
events = icalparser.parse_events(content=content, start=start, end=end)
if events is not None:
for event in events:
if event.all_day and not include_all_day:
continue
uid = None
if hasattr(event, "uid") and event.uid != -1:
uid = event.uid
data = {
"uid": uid,
"summary": event.summary,
"start": parser_icalevents.get_date_formatted(
event.start.astimezone(), event.all_day
),
"end": parser_icalevents.get_date_formatted(
event.end.astimezone(), event.all_day
),
"location": event.location,
"description": event.description,
}
# Note that we return a formatted date for start and end here,
# but a different format for get_current_event!
event_list.append(data)
return event_list
async def async_get_events(self, hass, start_date, end_date):
"""Get all events in a specific time frame."""
event_list = []
calendar_data = await hass.async_add_job(self._downloadCalendar)
events = None
try:
events = icalparser.parse_events(content=calendar_data, start=start_date, end=end_date)
except:
_LOGGER.error("%s: Failed to parse ICS!", self.name)
if events is not None:
for event in events:
if event.all_day and not self.include_all_day:
continue
uid = None
if hasattr(event, 'uid') and event.uid != -1:
uid = event.uid
data = {
'uid': uid,
'summary': event.summary,
'start': self.get_date_formatted(event.start.astimezone(), event.all_day),
'end': self.get_date_formatted(event.end.astimezone(), event.all_day),
'location': event.location,
'description': event.description
}
# Note that we return a formatted date for start and end here,
# but a different format for self.event!
event_list.append(data)
return event_list
def get_persons(self, date):
date = lmdutils.get_date_ymd(date)
if date in self.cache:
return self.cache[date]
res = parse_events(self.cal, start=date, end=date)
self.cache[date] = res = [
(p.summary, self.people.get_bzmail_from_name(p.summary)) for p in res
]
return res
def get_persons(self, date):
date = lmdutils.get_date_ymd(date)
date += relativedelta(seconds=1)
date = date.replace(tzinfo=self.cal_tz)
if date in self.cache:
return self.cache[date]
res = parse_events(self.cal, start=date, end=date)
self.cache[date] = res = [(p.summary,
self.people.get_bzmail_from_name(p.summary))
for p in res]
return res
def get_persons(self, date):
date = lmdutils.get_date_ymd(date)
date += relativedelta(seconds=1)
date = date.replace(tzinfo=self.cal_tz)
if date in self.cache:
return self.cache[date]
res = parse_events(self.cal, start=date, end=date)
self.cache[date] = res = [
(p.summary, self.people.get_bzmail_from_name(p.summary)) for p in res
]
return res
def events_at(time):
for name in calendars:
calendar = get_calendar(name)
# Vemos si podemos usar los eventos en caché o tenemos que parsear raw
if calendar[1] - calendar[2] <= time <= calendar[1] + calendar[2]:
events_gen = (e for e in calendar[0] if e.start <= time <= e.end)
else:
events_gen = (e for e in icalparser.parse_events(
calendar[3], start=time, end=time))
events = repeat_next(events_gen)
if next(events, None) is None:
yield '[%s] No tiene nada reservado' % name
for event in events:
yield '[%s] %s' % (name, event.summary)
def get_ics_events(files=None, remove_duplicates=True, days=30):
events_dict = {}
for ics_file in tqdm(files,
total=len(files),
desc=" Loading events from ics files"):
# open the file and parse ics calendar to list of events
try:
with open(ics_file) as f:
events_list = parse_events(
f.read(), default_span=datetime.timedelta(days=days))
except Exception as e:
print(ics_file)
raise e
# loop through all events in calendar
for new_event in events_list:
# add file field
new_event.file = ics_file
# if "Lunch" in new_event.summary:
# print()
# print(new_event, new_event.file, new_event.status)
# print(dir(new_event))
# print(new_event.uid.split("_")[0])
# print(new_event.recurrence_id)
# continue if uid already exists in dictionary
if new_event.uid in events_dict:
continue
if remove_duplicates:
# check if duplicate of event already exists (has different uid though)
duplicate = check_duplicate_event(new_event, events_dict)
events_dict, duplicate = check_modified_recurring_event(
new_event, events_dict)
if duplicate:
continue
# only add event uids that aren't duplicated
events_dict[new_event.uid] = new_event
return events_dict
def load_calendar(name, retries=3):
url = urls[name]
while retries > 0:
try:
now = aware_now()
span = timedelta(weeks=4)
calendar_raw = icaldownload.ICalDownload().data_from_url(url)
events = icalparser.parse_events(calendar_raw,
start=now - span,
end=now + span)
calendars[name] = (events, now, span, calendar_raw)
return calendars[name]
except Exception:
retries -= 1
# Debería levantar una excepción?
return None
def update(self):
"""Get the latest data."""
now = datetime.now().astimezone()
calendar_data = self._downloadCalendar()
events = None
try:
events = icalparser.parse_events(content=calendar_data, end=now)
except:
_LOGGER.error("%s: Failed to parse ICS!", self.name)
if events is not None:
temp_event = None
for event in events:
if event.all_day and not self.include_all_day:
continue
else:
event.start = event.start.astimezone()
event.end = event.end.astimezone()
# This first case probably isn't needed; when writing this
# code, I noticed that if an event hasn't started yet, it
# won't be returned at all. I've left the condition in,
# just in case that changes in the future.
if event.start > now or event.end < now:
continue
if temp_event is None:
temp_event = event
elif temp_event.end > event.end:
temp_event = event
if temp_event is None:
self.event = None
return True
self.event = {
'summary': temp_event.summary,
'start': self.get_hass_date(temp_event.start, temp_event.all_day),
'end': self.get_hass_date(temp_event.end, temp_event.all_day),
'location': temp_event.location,
'description': temp_event.description
}
return True
return False
print("The configuration file must contain at least a calendar key",
file=sys.stderr)
sys.exit(1)
update_freq = int(cal.get("update_frequency", 15))
sleep_seconds = update_freq * 60
sch = None
if sch_proc is not None:
print("Kill process")
sch_proc.terminate()
try:
client = caldav.DAVClient(url, username=user, password=password)
principal = client.principal()
except OSError:
print("Calendar fetch failed. Retrying in {} seconds.".format(
sleep_seconds),
file=sys.stderr)
time.sleep(sleep_seconds)
future_events = []
next_minute = datetime.now(pytz.utc) + timedelta(minutes=1)
for calendar in principal.calendars():
for event in calendar.events():
url = str(event.url)
url_base = url[url.rfind("/") + 1:]
ical_text = event.data
future_events += parse_events(ical_text, start=next_minute)
sch = sched.scheduler(lambda: datetime.now(pytz.utc), sleep_fun)
schedule.populate_scheduler(sch, future_events, conf)
sch_proc = Process(target=schedule.schedule_proc, args=(sch, ))
sch_proc.start()
time.sleep(sleep_seconds)
