def get_ica_file(vcal): #Download the ICA file req = urllib.request.Request(BASE_URL + "?Vcal=7." + vcal + "&Lo=bwh07&Jd=6558") f = urllib.request.urlopen(req) #Read the calendar into a cal variable return Calendar.from_ical(f.read())
def add_ical(generator, metadata): # check if a calendar is here if 'calendar' in metadata.keys(): summ = [] path = metadata['calendar'] if not os.path.isabs(path): path = os.path.abspath(metadata['calendar']) cal = Calendar.from_ical(open(path,'rb').read()) for element in cal.walk(): eventdict = {} if element.name == "VEVENT": if element.get('summary') != None: eventdict['summary'] = element.get('summary') if element.get('description') != None: eventdict['description'] = element.get('description') if element.get('url') != None: eventdict['url'] = element.get('url') if element.get('dtstart') != None: eventdict['dtstart'] = element.get('dtstart').dt if element.get('dtend') != None: eventdict['dtend'] = element.get('dtend').dt summ.append(eventdict) # the id of the calendar is the slugified name of the page calId = utils.slugify(metadata['title']) generator.context['events'][calId] = summ
def open_cal(): if os.path.isfile(filename): if file_extension == 'ics': print "Extracting events from file:", filename, "\n" f = open(sys.argv[1], 'rb') gcal = Calendar.from_ical(f.read()) # TODO: Let this parse multiple events in one ics file for component in gcal.walk(): event.summary = component.get('SUMMARY') event.uid = component.get('UID') event.description = component.get('DESCRIPTION') event.location = component.get('LOCATION') event.start = component.get('dtstart').dt event.end = component.get('dtend').dt event.url = component.get('URL') f.close() else: print "You entered ", filename, ". " print file_extension.upper(), " is not a valid file format. Looking for an ICS file." exit(0) else: print "I can't find the file ", filename, "." print "Please enter an ics file located in the same folder as this script." exit(0)
def voidwarranties(create_event): """ <p> Het is een locatie waar gelijkgestemden kunnen samenwerken aan projecten. Soms zijn dit electronica, informatica of gewoon kunstzinnige experimenten. Al dit experimenteren, of liever gezegd, hacken heeft maar één doel: de hackerspace upgraden tot een plaats die inspireert om nog leukere dingen te maken. </p> <p> Een locatie is 1 kant van het verhaal, aan de andere kant zijn er de leden en bezoekers, de échte bron van ideeën en kennis. </p> """ data = Calendar.from_ical(requests.get("http://voidwarranties.be/index.php/Special:Ask/-5B-5BCategory:Events-5D-5D/-3FHas-20start-20date=start/-3FHas-20end-20date=end/-3FHas-20coordinates=location/format=icalendar/title=VoidWarranties/description=Events-20at-20http:-2F-2Fvoidwarranties.be/limit=500").content) for event in data.walk()[1:]: title = str(event["SUMMARY"]) url = event["URL"] start = event["DTSTART"].dt if event.get("DTSTART") else event["DTSTAMP"].dt end = event["DTEND"].dt if event.get("DTSTART") else None db_event = create_event( title=title, url=url, start=start, end=end ) db_event.tags.add("hackeragenda")
def get_events_from_calendar(ics): """ Return a list with all events. """ calendar = Calendar.from_ical(ics) events = [event for event in calendar.walk() if isinstance(event, Event)] return events
def test_can_download_valid_ical(self): """ 正しい形式のiCalファイルをダウンロードできる """ from icalendar import Calendar from icalendar import vDatetime, vText e = EventFactory() user = PersonaFactory() e.attend(user) e.save() r = self.client.get('/events/{}/calendar/'.format(e.pk)) for content in r.streaming_content: cal = Calendar.from_ical(content) self.assertEqual(cal['version'], '2.0') self.assertEqual(cal['PRODID'], 'Kawaz') for component in cal.walk(): if component.name == 'VEVENT': self.assertEqual(component['summary'], e.title) self.assertEqual(component['description'], e.body) self.assertEqual(component['location'], e.place) self.assertEqual(component['dtstamp'].to_ical(), vDatetime(e.created_at).to_ical()) self.assertEqual(component['dtstart'].to_ical(), vDatetime(e.period_start).to_ical()) self.assertEqual(component['dtend'].to_ical(), vDatetime(e.period_end).to_ical()) self.assertEqual(component['class'].to_ical(), vText('PUBLIC').to_ical()) self.assertEqual(component['organizer'].params['cn'], e.organizer.nickname) self.assertEqual(component['organizer'].params['role'], e.organizer.role) # ATENDEEがセットされている for attendee, cal_attendee in zip(e.attendees.all(), component['attendee']): self.assertEqual(cal_attendee.params['cn'], attendee.nickname) self.assertEqual(cal_attendee.params['role'], attendee.role)
def icalendar_data(name, data): cal = Calendar.from_ical(data) @register_event def icalendar_fn(day): for e in cal.walk(): if isinstance(e, Event): title = e['SUMMARY'] url = e.get('URL', None) start = e['DTSTART'].dt if isinstance(start, datetime): startdate = start.date() starttime = start else: startdate = start starttime = None if startdate == day: event = "{}: {}".format(name, title) if starttime: if starttime.minute == 0: event += " {:%H}h".format(starttime) else: event += " {:%H:%M}".format(starttime) if url: event += " ({})".format(url) yield event
def parse_birthdays(data): birthdays = [] vcards = Calendar.from_ical(data, multiple=True) for vcard in vcards: birthday = vcard.get("bday") name = vcard.get("fn") if not birthday: continue match = re.search(r"^(\d{4})\-(\d{2})\-(\d{2})$", birthday) if not match: print("{} has an invalid birthday: {}".format(name, birthday), file=sys.stderr) continue year, month, day = match.groups() year, month, day = int(year), int(month), int(day) birthday = Birthday(name, year, month, day) birthdays.append(birthday) return birthdays
def get_future_todos(ics): with open(ics, 'r') as f: nodes = [] gcal = Calendar.from_ical(f.read()) for component in gcal.walk(): if component.name == "VEVENT": try: dtstart_dt = component.get('dtstart').dt dtend_dt = component.get('dtend').dt except AttributeError: continue if not is_in_future(dtstart_dt): continue if is_full_day(dtstart_dt, dtend_dt): date_part = dtstart_dt.strftime('%Y-%m-%d %a') else: # UTC hack hour = int(dtstart_dt.strftime('%H')) date_part = dtstart_dt.strftime('%Y-%m-%d %a {}:%M'.format(hour +1)) summary = component.get('summary') node = NODE_TEMPLATE.format(summary, date_part) nodes.append(node) return nodes
def parse(self, ical): parsed_calendar = ICalendar.from_ical(ical) self.calendar_timezone = pytz.timezone(parsed_calendar["X-WR-TIMEZONE"]) for subcomponent in parsed_calendar.subcomponents: if subcomponent.name == "VEVENT": self.import_event(self.calendar, subcomponent)
def index(request): try: response = urllib2.urlopen(ical_url) data = response.read() except: return HttpResponse("Unable to access calendar.", status=500) cal = Calendar.from_ical(data) now = timezone.now() today = date.today() events = [] for event in cal.walk('vevent'): start = event.decoded('dtstart') e = { 'title': event.decoded('summary'), 'start': start} # If start date is just a date (without time) if type(start) is type(today): if start > today: events.append(e) else: # Check if types (timezone or not) match try: start > now except TypeError: # Add timezone start = pytz.timezone("Europe/Helsinki").localize(start, is_dst=None) if start > now: events.append(e) return render_to_response('kalender/index.html', {"events":events}, context_instance=RequestContext(request))
def sync_with_ical(self, ical_feed, feed_url): """ Parse an icalendar feed and sync the events in the database with it. :param ical_feed: ical formatted string. :return: None """ today = utcnow().date() cal = Calendar.from_ical(ical_feed) for event in cal.walk('vevent'): uid = event.decoded('uid') sequence = event.decoded('sequence') try: event_obj = self.get(id=uid) if event_obj and event_obj.sequence == sequence: continue except Event.DoesNotExist: event_obj = Event() event_obj.update_from_ical(event) end_date = event_obj.end_time if isinstance(end_date, datetime): # use date since some feeds only produce date objects end_date = end_date.date() if today > end_date: continue if not event_obj.url and 'google.com' in feed_url: event_obj.url = calendar_url_for_event(event_obj, calendar_id_from_google_url(feed_url)) event_obj.save()
def create_events_from_ics(self): filename = '/home/bschreiber/Downloads/adecalendar.ics' cal = Calendar.from_ical(open(filename,'rb').read()) calendar_items = cal.walk() pwflow = self.portal_workflow events_folder = self.events buff = StringIO() num_events_created = 0 for cal_item in calendar_items: if cal_item.name == 'VEVENT': title = cal_item['SUMMARY'].title() description = cal_item['DESCRIPTION'].title() organizer = cal_item['ORGANIZER'].title() location = cal_item['LOCATION'].title() start = cal_item['DTSTART'].dt end = cal_item['DTEND'].dt ev_id = idnormalizer.normalize(title) id_extension = 1 keep_trying = True while keep_trying: try: event_id = events_folder.invokeFactory('Event', id=ev_id, title=title) ev_obj = events_folder[event_id] ev_obj.setStartDate(start) ev_obj.setEndDate(end) ev_obj.setLocation(location) ev_obj.setText(description) keep_trying = False num_events_created +=1 buff.write('Created event with id '+ev_id+'\n') except Exception, e: ev_id = ev_id[:len(ev_id)-2]+'-'+str(id_extension) id_extension += 1
def _read_calendar_object(self, file_contents): try: return Calendar.from_ical(file_contents) except Exception as pe: msg1 = _("Unable to read calendar data.") msg2 = "\n\n" + ex_msg(pe) raise TimelineIOError(msg1 + msg2)
def getFeed(calFeed): message = "" date = "" headers = {"Cache-Control": "no-cache", "Pragma": "no-cache"} requests.packages.urllib3.disable_warnings() r = requests.get(calFeed, headers=headers) if r.status_code == 304: # read from cached file cf = open(cachefile, "r") caldata = cf.read() else: caldata = r.content cf = open(cachefile, "w") cf.write(caldata) cf.close() todayDates = [] tomorrowDates = [] cal = Calendar.from_ical(caldata) for event in cal.walk("VEVENT"): message = event.get("SUMMARY") date = event.get("DTSTART").dt if date == datetime.today().date(): todayDates.append({"Line": message, "Date": date}) elif date == datetime.today().date() + timedelta(days=1): tomorrowDates.append({"Line": message, "Date": date}) return [todayDates, tomorrowDates]
def ics(group): locale.setlocale(locale.LC_ALL, 'fr_FR.utf8') login, pw = read_credentials() request = requests.get( 'https://edt.univ-nantes.fr/sciences/' + group + '.ics', auth=(login, pw)) if not 200 <= request.status_code < 300: return "Error status while retrieving the ics file." format = "%Y%m%dT%H%M%SZ" now = datetime.utcnow().strftime(format) paris = pytz.timezone('Europe/Paris') current = '99991231T235959Z' dtstart = dtend = description = '' for component in Calendar.from_ical(request.text).walk(): if component.name == 'VEVENT': current_start = component.get('DTSTART').to_ical() if now > current_start: continue if current_start < current: current = current_start description = unicode(component.get('DESCRIPTION')) start = component.get('DTSTART').to_ical() end = component.get('DTEND').to_ical() dtutcstart = utc.localize(datetime.strptime(start, format)) dtutcend = utc.localize(datetime.strptime(end, format)) dtstart = dtutcstart.astimezone(paris) dtend = dtutcend.astimezone(paris) result = (u"Prochain cours le {date} de {start} à {end} :\n" "{description}").format( date=dtstart.strftime("%A %d/%m/%Y"), start=dtstart.strftime("%Hh%M"), end=dtend.strftime("%Hh%M"), description=description).encode('utf8').strip() return result
def get_events(ical_url, days=7): today = datetime.date.today() max_date = today + datetime.timedelta(days) ltz = tzlocal.get_localzone() events = [] ics = urllib.urlopen(ical_url).read() ical=Calendar.from_ical(ics) for e in ical.walk(): if 'SUMMARY' in e and 'DTSTART' in e: event = { 'title': str(e['SUMMARY'].encode('utf-8')), 'location': str(e['LOCATION'].encode('utf-8')), 'description': str(e['DESCRIPTION'].encode('utf-8')), } if type(e['DTSTART'].dt) is datetime.datetime: event['start'] = e['DTSTART'].dt.replace(tzinfo=pytz.utc) event['date'] = event['start'].astimezone(ltz).date() else: event['start'] = e['DTSTART'].dt event['date'] = event['start'] if 'DTEND' in e: if type(e['DTEND'].dt) is datetime.datetime: event['end'] = e['DTEND'].dt.replace(tzinfo=pytz.utc) else: event['end'] = e['DTEND'].dt if today <= event['date'] and event['date'] <= max_date: events.append(event) return(sorted(events, key=itemgetter('date')))
def relab(create_event): """ <p><strong>Le RElab, premier Fab Lab de Wallonie, est un atelier numérique ouvert au public et une structure de développement créatif local.</strong> La spécificité du RElab réside dans l’utilisation de matériaux de récupération comme matière première et dans l’étude de nouveaux procédés sociaux, créatifs et économiques d’upcycling, en liaison avec les nouveaux moyens de fabrication et de communication numérique.</p> """ data = Calendar.from_ical(requests.get("https://www.google.com/calendar/ical/utmnk71g19dcs2d0f88q3hf528%40group.calendar.google.com/public/basic.ics").content) for event in data.walk()[1:]: if event.get("DTSTAMP"): title = str(event["SUMMARY"]) if event.get("SUMMARY") else "" url = str(event["URL"]) if event.get("URL") else "http://relab.be" start = str(event["DTSTART"].dt) if event.get("DTSTART") else str(event["DTSTAMP"].dt) end = str(event["DTEND"].dt) if event.get("DTEND") else None location = event["LOCATION"] # timezone removal, the crappy way if len(start) > 10: start = start[:-6] if len(end) > 10: end = end[:-6] event = create_event( title=title, url=url, start=start, end=end, location=location ) event.tags.add("fablab")
def order(group): global request if request == "": request = connect(group) # objet reçu de la connexion via la # fonction connect définie plus bas. paris = pytz.timezone('Europe/Paris') format = "%Y%m%dT%H%M%SZ" datefind = datetime(2014, 4, 16, 11) # careful: 04 is invalid. 4 # is. (octal numbers not allowed in python!) find = datefind.strftime("%d/%m/%Y/%Hh%M") ffind = utc.localize(datefind) fffind = ffind.astimezone(paris) #semaine de 4 à 22 (19 semaine) #semaine de 6 jour #jour de 8 crénaux #tableau de 19 * 6 * 8 = 912 case crenaux = [1]*912 for component in Calendar.from_ical(request.text).walk(): if component.name == 'VEVENT': start = component.get('DTSTART').to_ical() dtutcstart = utc.localize(datetime.strptime(start, format)) dtstart = dtutcstart.astimezone(paris) fstart = dtstart.strftime("%d/%m/%Y/%Hh%M") end = component.get('DTEND').to_ical() dtutcend = utc.localize(datetime.strptime(end, format)) dtend = dtutcend.astimezone(paris) fend = dtend.strftime("%d/%m/%Y/%Hh%M") getCrenaux(crenaux, dtstart, dtend) return crenaux
def sync_with_ical(self, ical_feed): """ Parse an icalendar feed and sync the events in the database with it. :param ical_feed: ical formatted string. :return: None """ cal = Calendar.from_ical(ical_feed) current_uids = self.values_list('id', flat=True) new_uids = [] for event in cal.walk('vevent'): uid = event.decoded('uid') sequence = event.decoded('sequence') new_uids.append(uid) try: event_obj = self.get(id=uid) if event_obj and event_obj.sequence == sequence: continue except Event.DoesNotExist: event_obj = Event() event_obj.update_from_ical(event) event_obj.save() to_delete = set(current_uids) - set(new_uids) self.filter(id__in=list(to_delete)).delete()
def make_db(): from ..database import Event print "Converting iCal file into sqlite database..." with open(ICAL_PATH, 'rb') as f: ical_data = f.read() cal = Calendar.from_ical(ical_data) try: Event.drop_table() except: pass try: Event.create_table() except: pass for event in cal.walk("VEVENT"): Event.create_from_ical_event(event) print "Imported {} events.".format( Event.select().count() ) return True
def fetch(create_event): data = Calendar.from_ical(requests.get("http://www.meetup.com/{}/events/ical/".format(meetup_name)).content) for event in data.walk(): if not isinstance(event, icalendarEvent): continue title = event.get("SUMMARY", None) start = event.get("DTSTART", None) if None in (title, start): continue detail = { "title": title.encode("Utf-8"), "url": event.get("URL", ""), "start": start.dt.replace(tzinfo=None), "location": event.get("LOCATION", "").encode("Utf-8"), } if key is None and event.get("URL") and Event.objects.filter(url=event["url"]): continue elif callable(key) and key(event_query=Event.objects.filter(source=org_name), detail=detail) is False: continue db_event = create_event(**detail) if filter(lambda x: not callable(x), tags): db_event.tags.add(*filter(lambda x: not callable(x), tags)) map(lambda tag: tag(db_event), filter(callable, tags))
def __init__(self, start_time, pattern): super(ICal, self).__init__(start_time, pattern) cal = Calendar.from_ical(pattern) vevent = cal.walk('VEVENT')[0] self.dtstart = start_time self.min_freq = self._get_min_freq(vevent) self.rrule_obj = self._get_rrule_obj(vevent, start_time)
def reload(self, sender): calendar_url = CONFIG.get('feed', 'nag') try: result = requests.get(calendar_url) except IOError: self.last_pomodoro_name = 'Error loading calendar' self.last_pomodoro_timestamp = self.now().replace(microsecond=0) return cal = Calendar.from_ical(result.text) recent = None for entry in cal.subcomponents: if recent is None: recent = entry continue if 'DTEND' not in entry: continue if entry['DTEND'].dt > recent['DTEND'].dt: recent = entry self.last_pomodoro_name = recent['SUMMARY'] self.last_pomodoro_timestamp = recent['DTEND'].dt
def update_engineering_events(): r = requests.get('http://engineering.columbia.edu/feeds/events') soup = BeautifulSoup(r.text) events = soup.find_all('item') user = User.query.filter(User.name == "Columbia Engineering").first() for event in events: current_soup = BeautifulSoup(event.renderContents()) event_name = current_soup.find('title').text url = current_soup.find('link').get_text() u = urlparse.urlparse(url) event_id = urlparse.parse_qs(u.query)["id"][0] base = "http://calendar.columbia.edu/sundial/webapi/" ical_url = base + "iCalendar.php?EventID={}".format(event_id) url = base + "get.php?vt=detail&id={}&con=standalone".format(event_id) r_event = requests.get(ical_url) cal = Calendar.from_ical(r_event.text) cevent = Event.query.filter(Event.sundial_id == event_id).first() if cevent is None: cevent = Event(name=event_name, url=url, sundial_id=event_id, user_id=user.id) # only one event in cal for event in cal.walk('vevent'): cevent.start = event.get('dtstart').dt.replace(tzinfo=None) cevent.end = event.get('dtend').dt.replace(tzinfo=None) cevent.description = event.get('description') cevent.location = event.get('location') db.session.add(cevent) db.session.commit()
def generic_meetup(source, meetup_name, options): Event.objects.filter(source=source, start__gte=datetime.now()).delete() data = Calendar.from_ical(requests.get("http://www.meetup.com/{}/events/ical/".format(meetup_name)).content) for event in data.walk(): if not isinstance(event, icalendarEvent): continue title = event.get("SUMMARY", None) start = event.get("DTSTART", None) if None in (title, start): continue if event.get("URL") and Event.objects.filter(url=event["url"]): continue Event.objects.create( title=title.encode("Utf-8"), source=source, url=event.get("URL", ""), start=start.dt.replace(tzinfo=None), location=event.get("LOCATION", "").encode("Utf-8") ) if not options["quiet"]: print "Adding %s [%s] (%s)..." % (title.encode("Utf-8"), source, event.get("LOCATION", "").encode("Utf-8"))
def _load_calendar(): logging.debug("Loading Calendar from: %r", settings.ICAL_URL) ical_request = requests.get(settings.ICAL_URL) cal = Calendar.from_ical(ical_request.text) for k in cal.subcomponents: logging.debug('Calendar - %r', k) return cal
def fetch(create_event): data = Calendar.from_ical(requests.get("http://www.meetup.com/{}/events/ical/".format(meetup_name)).content) for event in data.walk(): if not isinstance(event, icalendarEvent): continue title = event.get("SUMMARY", None) start = event.get("DTSTART", None) if None in (title, start): continue if event.get("URL") and Event.objects.filter(url=event["url"]): continue db_event = create_event( title=title.encode("Utf-8"), url=event.get("URL", ""), start=start.dt.replace(tzinfo=None), location=event.get("LOCATION", "").encode("Utf-8"), ) if tags: db_event.tags.add(*tags)
def read(ical): """ @desc: Read the ical file and parse into a dict. """ gcal = Calendar.from_ical(ical) events = [] for event in gcal.walk('VEVENT'): end = event.decoded('DTEND') if type(end) == datetime.date: now = datetime.date.today() else: now = timezone.now() if end < now: continue summary = event.get('SUMMARY') description = event.get('DESCRIPTION') location = event.get('LOCATION') geo = event.get('GEO') url = event.get('URL') attach = event.get('ATTACH') events.append(dict({ "summary": str(summary) if summary else str(), "start": event.decoded('DTSTART').isoformat(), "end": event.decoded('DTEND').isoformat(), "description": str(description) if description else str(), "location": str(location) if location else str(), "geo": str(geo) if geo else str(), "url": str(url) if url else str(), "attach": str(attach) if attach else str(), })) return events
def main(argv): parser = configargparse.ArgumentParser(description="iCal task importer for Todoist", formatter_class=RawTextHelpFormatter) parser.add_argument( '-f', '--filename', required=True, type=str, help='iCal file to import' ) parser.add_argument( '-t', '--api_token', required=True, type=str, help='Todoist API token' ) parser.add_argument( '-p', '--project', required=True, type=str, help='Destination Todoist project for these tasks' ) parser.add_argument( '-r', '--reminders', help='Add reminders to tasks that have a due date specified\nREQUIRES TODOIST PREMIUM\nDefault: False', action='store_true') parser.add_argument( '--debug', help='Run in debug mode (prints more information to the logfile)\nDefault: False', action='store_true') parser.add_argument( '--noop', help='Parse the iCal data but don\'t actually commit to the Todoist API\nDefault: False', action='store_true') args=parser.parse_args() if args.debug: logger.setLevel(logging.DEBUG) cal = Calendar.from_ical( open(args.filename, 'rb').read() ) tdapi = TodoistAPI(args.api_token, args.noop==False) project = tdapi.get_project(args.project) logger.debug('Using project %s' % project.data) new_items = [] for ical_item in cal.walk('vtodo'): item = tdapi.add_item(project, ical_item) new_items.append(item) tdapi.commit() if args.reminders: for item in new_items: tdapi.add_reminder(item) tdapi.commit()
def calendar_addics(caldav_conn, args): """ Takes an ics from external source and puts it into the calendar. From the CalDAV RFC: Calendar components in a calendar collection that have different UID property values MUST be stored in separate calendar object resources. This means the inbound .ics has to be split up into one .ics for each event as long as the uid is different. """ if args.file == '-': input_ical = sys.stdin.read() else: with open(args.file, 'r') as f: input_ical = f.read() c = Calendar.from_ical(input_ical) ## unfortunately we need to mess around with the object internals, ## since the icalendar library doesn't offer methods out of the ## hat for doing such kind of things entries = c.subcomponents ## Timezones should be duplicated into each ics, ref the RFC timezones = [x for x in entries if x.name == 'VTIMEZONE'] ## Make a mapping from UID to the other components uids = {} for x in entries: if x.name == 'VTIMEZONE' or not 'UID' in x: continue uid = x['UID'].to_ical() uids[uid] = uids.get(uid, []) + [x] for uid in uids: c.subcomponents = timezones + uids[uid] _calendar_addics(caldav_conn, c.to_ical(), uid, args)
def open_cal(): if os.path.isfile(filename): if file_extension == 'ics': print("Extracting events from file:", filename, "\n") f = open(sys.argv[1], 'rb') gcal = Calendar.from_ical(f.read()) revents = recurring_ical_events.of(gcal).between(istart, istop) # for component in gcal.walk(): for component in revents: event = CalendarEvent("event") v = (dir(component).count('get') ) # Only proces data if object is a valid event if (v != 0): if component.get('TRANSP') == 'TRANSPARENT': continue #skip all day events and the like if component.get('SUMMARY') == None: continue #skip blank items event.summary = component.get('SUMMARY') event.uid = component.get('UID') if hasattr(component.get('dtstart'), 'dt'): event.start = component.get('dtstart').dt if hasattr(component.get('dtend'), 'dt'): event.end = component.get('dtend').dt event.url = component.get('URL') events.append(event) f.close() else: print("You entered ", filename, ". ") print(file_extension.upper(), " is not a valid file format. Looking for an ICS file.") exit(0) else: print("I can't find the file ", filename, ".") print( "Please enter an ics file located in the same folder as this script." ) exit(0)
def get_race_name_list(target_year, is_place): """Getting the race name and event date Arguments: target_year {int} -- target year to get the data is_place {bool} -- [description] Returns: [list in dict] -- event date and race name """ zip_url = ICAL_PLACE_DOWNLOAD_URL if is_place else ICAL_FILE_DOWNLOAD_URL ical_name = ICAL_PLACE_NAME if is_place else ICAL_FILE_NAME url_path = zip_url.format(year=target_year) file_name = ical_name.format(year=target_year) zip_obj = requests.get(url_path) with zipfile.ZipFile(io.BytesIO(zip_obj.content)) as unzipped_obj: with unzipped_obj.open(file_name) as ical_obj: cal = Calendar.from_ical(ical_obj.read()) return [{ "date": ev["dtend"].dt, "title": str(ev["summary"]).split("(")[0] } for ev in cal.walk() if ev.name == "VEVENT"]
def import_ics(self): ics = base64.b64decode(self.ics_file) lines = [] for event in Calendar.from_ical(ics).walk('vevent'): dtend = event.get('dtend').dt dtstart = event.get('dtstart').dt day_count = (dtend - dtstart).days if day_count > 1: for dt in (dtstart + timedelta(n) for n in range(day_count)): lines.extend([(0, 0, { 'name': event.get('summary'), 'date': dt.strftime(DF) })]) else: lines.extend([(0, 0, { 'name': event.get('summary'), 'date': dtstart.strftime(DF) })]) if lines: holidays = self.env['hr.holidays.public'].browse( self._context.get('active_id', [])) holidays.write({'line_ids': lines})
def convert_calendar(calendar, date): # Open file with the ics calendar in it and then read it into an icalendar object. f = open(calendar, 'rb') process_cal = Calendar.from_ical(f.read()) f.close() # cal_events is a list of every event in the calendar. cal_events = [e for e in process_cal.walk('vevent')] first_event_date = get_first_event_date(cal_events) # The offset is how many days we are moving the dates of the calendar. offset = date - first_event_date # Every date in every event is moved by the offset. for e in cal_events: e['DTSTART'].dt = e['DTSTART'].dt + offset e['DTEND'].dt = e['DTEND'].dt + offset # Call function to change weekly dates. change_weekly(cal_events) # output to file. f = open('output.ics', 'wb') f.write(process_cal.to_ical()) f.close()
def parse_events_from_ics(ics_contents: bytes) -> List[dict]: parsed_events = [] cal = Calendar.from_ical(ics_contents) now = epoch_now() for item in cal.walk(): if item.name == 'VEVENT': category = item.get('categories').to_ical().decode('utf-8') summary = item.get('summary').to_ical().decode('utf-8') timestamp = item.get('dtend', 0).to_ical().decode('utf-8') summary += f' [{time_from_ics_stamp(timestamp)}]' timestamp = ics_format_to_epoch(timestamp) if timestamp < now: continue parsed_events.append({ 'category': ''.join(category), 'timestamp': timestamp, 'msg': summary }) return parsed_events
def load_osdc(): cal = Calendar.from_ical(open('data/osdc.ics', 'rb').read()) speakers = {} osdc1 = Track2.query.get(28) osdc2 = Track2.query.get(48) osdc3 = Track2.query.get(49) for component in cal.walk(): if component.name != 'VEVENT': continue title = component['summary'] room_name = component['location'] abstract = component['description'] speaker_name = component['organizer'] starts_at = component['dtstart'].dt ends_at = component['dtend'].dt duration = int((ends_at - starts_at).total_seconds() / 60) speaker = speakers.get(speaker_name, None) if not speaker: speaker = Speaker(first_name="", last_name=speaker_name) speakers[speaker_name] = speaker talk = Talk(title=title, abstract=abstract, starts_at=starts_at, duration=duration) talk.speakers.append(speaker) if 'Gopher' in room_name: talk.track = osdc3 else: if starts_at.day == 4: talk.track = osdc1 else: talk.track = osdc2 db.session.commit()
def create_event(self, uid, title, message, location=None, start=None, stop=None): ical = Calendar.from_ical(self.__ical_data) if uid is None: uid = md5(title.encode()).hexdigest() if start is None: start = datetime.now() if stop is None: stop = start event = Event() event.add('uid', str(datetime.now()) + '/' + str(start) + '/' + str(uid)) event.add('summary', title) event.add('description', message) if location is not None: event.add('location', location) event.add('dtstart', start) event.add('dtend', stop) event.add('dtstamp', datetime.now()) ical.add_component(event) with open(terrariumCalendar.ICS_FILE, 'wb') as fp: fp.write(ical.to_ical()) self.__ical_data = ical.to_ical()
def load_events(filepath): with open(filepath) as f: gcal = Calendar.from_ical(f.read()) events = [] for component in gcal.walk(): if component.name == "VEVENT": # TODO: Test that timezones work properly # TODO: Handle recurrence rules title = component.decoded("summary").decode("utf8") start = coerce2datetime(component.decoded("dtstart")) end = coerce2datetime(component.decoded("dtend")) duration = end - start attendees = [ str(attendee) for attendee in (component.get("attendee") or []) ] e = Event( timestamp=start, duration=duration, data={ "title": title, "attendees": attendees }, ) events.append(e) # print(title) # print(start, duration) # if attendees: # for attendee in attendees: # print(attendee) # print(e) # print(component) # print(80 * "-") return events
def blogTO(): host = "http://www.blogto.com" dateRange = getDateRange("%d-%d-%d", numberOfDays, False) print dateRange for currentDate in dateRange: urls = [] soup = getBS(host + "/events/?date=" + currentDate) for event in soup.select(".event-name a"): urls.append(host + event.get('href')) print urls for url in urls: #check if feature already exists if url not in existingFeatures: print url r = requests.get(url + "add-to-calendar/?type=ical") cal = Calendar.from_ical(r.text) r = requests.get(url) eventHTML = r.text img = "" soup = BeautifulSoup(eventHTML) for event in soup.select(".detail-img-container > img"): img = event.get("src") m = re.search('(coordinates: \'POINT \()(.*)(\s)(.*)(\))', eventHTML) if m: long = m.group(2) lat = m.group(4) else: lat, long = lookupVenue(cal = cal, source = "blogTO") if lat: readCalendarEventAndSubmit(cal, lat, long, url, "%Y-%m-%d %H:%M:%S", "blogTO", img = img)
def open_cal(): if os.path.isfile(filename): if file_extension == 'ics': print("Extracting events from file:", filename, "\n") f = open(sys.argv[1], 'rb') gcal = Calendar.from_ical(f.read()) for component in gcal.walk(): event = CalendarEvent("event") if component.get('TRANSP') == 'TRANSPARENT': continue #skip event that have not been accepted if component.get('SUMMARY') == None: continue #skip blank items event.summary = component.get('SUMMARY') event.uid = component.get('UID') if component.get('DESCRIPTION') == None: continue #skip blank items event.description = component.get('DESCRIPTION') event.location = component.get('LOCATION') if hasattr(component.get('dtstart'), 'dt'): event.start = component.get('dtstart').dt if hasattr(component.get('dtend'), 'dt'): event.end = component.get('dtend').dt event.url = component.get('URL') events.append(event) f.close() else: print("You entered ", filename, ". ") print(file_extension.upper(), " is not a valid file format. Looking for an ICS file.") exit(0) else: print("I can't find the file ", filename, ".") print( "Please enter an ics file located in the same folder as this script." ) exit(0)
def getCalendarData(calendar_url): req = urllib2.Request(calendar_url) response = urllib2.urlopen(req) data = response.read() today = datetime.now().date() in_future = today + timedelta(days=15) cal = Calendar.from_ical(data) events = [] for event in cal.walk('vevent'): if not "QUIET TIME" in upper(event.get("summary")): continue if (event.get('rrule')): start = event.get('dtstart').dt duration = event.get('dtend').dt - start try: rrule = rrulestr(event.get('rrule').to_ical(), dtstart=start) start = rrule.after(datetime.now(pytz.UTC)) except: rrule = rrulestr(event.get('rrule').to_ical(), dtstart=start) start = rrule.after(datetime.now().replace(tzinfo=None)) if start: start.replace(tzinfo=pytz.UTC) if start: end = start + duration else: continue else: start = event.get('dtstart').dt end = event.get('dtend').dt if ((to_date(start) >= today) and (to_date(end) <= in_future)): events.append({ "start": start, "end": end, "summary": event.get("summary"), }) return events
def execute(content): gcal = Calendar.from_ical(content) ncal = Calendar() ncal.add('METHOD', gcal.get("METHOD")) ncal.add('VERSION', gcal.get("VERSION")) ncal.add('CALSCALE', gcal.get("CALSCALE")) ncal.add('X-WR-TIMEZONE', gcal.get("X-WR-TIMEZONE")) ncal.add('X-PUBLISHED-TTL', gcal.get("X-PUBLISHED-TTL")) ncal.add('PRODID', gcal.get("PRODID")) ncal.add('X-WR-CALNAME', gcal.get("X-WR-CALNAME")) ncal.add('X-WR-CALDESC', gcal.get("X-WR-CALDESC")) tum_events = [] for component in gcal.walk(): if component.name == "VEVENT": event = parse_event(component) duplicate_event = False for item in tum_events: if item.is_event(event): duplicate_event = True item.add_location(event.location) break if not duplicate_event: tum_events.append(event) event_str = '' for event_item in tum_events: event_str += event_item.summary cal_event = event_item.gen_event() ncal.add_component(cal_event) return ncal.to_ical()
def lookupEventInformation(self, calendarData, typeOfEvent, startTime=None, endTime=None, duration=None): calenderAsObject = Calendar.from_ical(calendarData.calendarData) eventList = calenderAsObject.walk( 'VEVENT') #grab all the events in the calendar result = [] if eventList is not None and len(eventList) > 0: (actualStartTime, actualEndTime) = self.addEvents(eventList, typeOfEvent, startTime, endTime, duration) eventNames = [ self.getEventName(event[COMMENT_KEY]) for event in eventList if self.eventMatches( event, typeOfEvent, actualStartTime, actualEndTime) ] if typeOfEvent == TOPIC_ID: result = [ self.DB_BRIDGE.retrieveTopicFromCacheOrDB(topicId, True) for topicId in eventNames ] elif typeOfEvent == TASK_ID: result = [ self.DB_BRIDGE.retrieveTaskFromCacheOrDB(taskId, True) for taskId in eventNames ] #remember to return the result in serializable form. result = [x.toSerializable() for x in result] return result
def main(): """Erase all events and send a new ics file from Emacs. """ credentials = get_credentials() http = credentials.authorize(httplib2.Http()) service = discovery.build('calendar', 'v3', http=http) # ------------------------------------------------------------ # Clear all events service.calendars().clear(calendarId='primary').execute() # ------------------------------------------------------------ # Add event one by one count = 0 g = open('/home/rafatieppo/Dropbox/emacs_org_mode/rafa.ics', 'rb') gcal = Calendar.from_ical(g.read()) for component in gcal.walk(): if component.name == "VEVENT": envent_summary = (component.get('summary')) event_dtstart = (component.get('dtstart').dt.isoformat() + '-04:00') event_dtend = (component.get('dtend').dt.isoformat() + '-04:00') event = { 'summary': envent_summary, 'start': { 'dateTime': event_dtstart }, 'end': { 'dateTime': event_dtend } } count = count + 1 print(str(count)) print(event) service.events().insert(calendarId='primary', body=event).execute() g.close()
def _extract_info_from_message_naive(self, message, cid_pattern, start_time_pattern, end_time_pattern): cid = None start_time = None end_time = None message_body = None for message_part in message.walk(): # Get a message body if this message part has one if message_part.get_content_type() == "text/plain": message_body = message_part.get_payload(decode=True) elif message_part.get_content_type() == "text/html": message_body = message_part.get_payload(decode=True) elif message_part.get_content_type() == "text/calendar": message_body = message_part.get_payload(decode=True) ics = Calendar.from_ical(message_body) start_time, end_time = self.extract_times_from_ical(ics) else: continue # We don't know how to parse this message part type if not message_body: continue # The message part couldn't be decoded. Skip it. # Parse the message body message_body = str(message_body) match = re.search(cid_pattern, message_body, re.IGNORECASE) if match: cid = match.group(1) match = re.search(start_time_pattern, message_body, re.IGNORECASE) if match: start_time = match.group(1) match = re.search(end_time_pattern, message_body, re.IGNORECASE) if match: end_time = match.group(1) # If we have all of the things we need stop looking #if cid and start_time and end_time: # break return cid, start_time, end_time, message_body
def get_checkin_agenda(url, name): req = Request(url) req.add_header('User-agent', 'Mozilla 5.10') gcal = Calendar.from_ical(urlopen(req).read().decode('utf-8')) agenda = Calendar() agenda['prodid'] = gcal['prodid'] agenda['version'] = '2.0' agenda['calscale'] = 'GREGORIAN' agenda['method'] = 'PUBLISH' for c in gcal.walk(): if c.name == 'VEVENT' and 'description' in c: check_in = Event() check_in['summary'] = "CHECKIN - " + name check_in['description'] = c['description'] # check_in['location'] = c['location'] check_in['dtstart'] = check_in['dtend'] = c['dtstart'] check_in['uid'] = "checkin-" + c['uid'] agenda.add_component(check_in) return agenda
def upload_calendar(request): classes = [] if request.user.is_authenticated: f = request.FILES["file"] f.seek(0) fcal = Calendar.from_ical(f.read()) for component in fcal.walk(): if component.name == "VEVENT": x = findOrCreateSession(component) if x not in classes: classes.append(x) classes = removePracticals(classes) for x in classes: x.save() if x.course not in request.user.courses.all(): request.user.courses.add(x.course) request.user.save() return redirect(request.POST["backurl"])
def get_calendar(self): url = config.ICAL_URL try: with urllib.request.urlopen(url) as response: data = response.read().decode('utf-8') except ValueError as e: logger.error( "%s Did you remember to preprend http(s?):// URL: '%s'" % (e, url)) return except urllib.error.HTTPError as e: logger.error("Received HTTP error code %s. URL: '%s'" % (e.code, url)) return try: cal = Calendar.from_ical(data) except ValueError as e: logger.error("Could not parse response as ical.") logger.debug("Response was %s" % (data)) return return cal
def class_finder(self): #This function downloads an ical file from the users input, reads from the file, and then deletes the file from memory r = requests.get(self.url,allow_redirects=True) f1 = open('classes.ical', 'wb').write(r.content) fall_classes_list = [] spring_classes_list = [] spring_ending = [datetime.datetime(2019,4,23,23,59,59)] from icalendar import Calendar f = open("classes.ical","rb") fcal = Calendar.from_ical(f.read()) for component in fcal.walk(): if component.name == "VEVENT": if component.get("RRULE")["UNTIL"] == spring_ending and component.get("SUMMARY") not in spring_classes_list: spring_classes_list.append(component.get("SUMMARY")) elif component.get("RRULE")["UNTIL"] != spring_ending and component.get("SUMMARY") not in fall_classes_list: fall_classes_list.append(component.get("SUMMARY")) f = open("people.csv","a") f.write(self.x + "||") f.write(self.y + "||") for entry in spring_classes_list: f.write(entry + "||") f.write("\n") f.close() os.remove("classes.ical")
def main(url, output_file_name, include_exercise_sessions): cal_text = read_url(url) cal_input = Calendar.from_ical(cal_text, True) cal_output = Calendar() for event in cal_input[0].walk('vevent'): try: event_type = parse_event_type(event) course_code = parse_course_code(event) event_room = parse_event_room(event) course_name = get_course_name(course_code) if should_ignore_event_type(event_type, include_exercise_sessions): continue event['summary'] = generate_event_description(course_code, event_type, event_room, course_name) cal_output.add_component(event) except AttributeError: continue with open(output_file_name, 'wb') as output_file: output_file.write(cal_output.to_ical())
def parse_fixture_to_list(): match_list = [] g = open('fixture.ics', 'rb') gcal = Calendar.from_ical(g.read()) for component in gcal.walk(): g_list = [] game_list = [] if component.name == "VEVENT": start_date = component.decoded('DTSTART') match = component.get('DESCRIPTION') year = start_date.year if year == 2016: match = match.replace('\n', ',') #print match g_tuple = (re.split(',|\sv\s', match)) #print g_tuple game_list.append(g_tuple[0]) game_list.append(g_tuple[1]) start_date = start_date.replace(tzinfo=None) game_list.append(start_date) match_list.append(game_list) g.close() return match_list
def main(): creds = check_credentials() service = build('calendar', 'v3', credentials=creds) globalid = '*****@*****.**' testglobalid = '*****@*****.**' calendarid = globalid with open("api_key", "r") as f: api_key = f.read() ioc_names = e2g.name2ioc() for src in sources: print("importing from {}".format(src.url)) r = requests.get(src.url, headers={'Accept': 'text/calendar'}) if not r.encoding: r.encoding = 'utf-8' events = googleify(Calendar.from_ical(r.text), src.tags, api_key, ioc_names, src.lat, src.lng) print("importing {} from from {}".format(len(events), src.url)) for event in events: print(' ' + event['summary']) insertupdate(calendarid, service, event, event['iCalUID'])
def fetch_events(self, timeout: int = 5) -> None: """ Fetch events from Wirtualna Uczelnia """ try: calendar: Calendar = Calendar.from_ical( requests.get(self._url, verify=False, timeout=timeout).text # nosec ) # type: ignore except requests.exceptions.ConnectTimeout as e: raise WUDeadError(e) except Exception as e: raise ScheduleFetchError(e) # create a list of events out of the calendar self.events = [ Event.from_calendar(component) for component in calendar.walk() if component.name == "VEVENT" ] self.first_day = min(self.events, key=lambda e: e.start).start.date() self.last_day = max(self.events, key=lambda e: e.start).start.date()
def test_parser(icalendarFile, outputFileName): try: data = urlopen(icalendarFile) print("URL") except: data = open(icalendarFile, "r", encoding='utf-8') print("Path") datas = data.read() cal = Calendar.from_ical(datas) """ Go through the events and parse the information: """ for event in cal.walk('vevent'): event_info = ','.join(event.get('summary').rsplit('(', 1)) parser = MyCoursesParser() parser.parse(event_info) if parser.infos["errors"] is not None: continue summary = parser.infos["summary"] course_code = parser.infos["course_code"] location = parser.infos["location"] address = parser.infos["address"] descr = event.get('description') description, webPage = form_description(course_code, descr) geo = getLocation(address) event['summary'] = summary event['description'] = description event['location'] = location event['geo'] = geo event['url'] = webPage outputFile = open(outputFileName, 'wb') outputFile.write(cal.to_ical()) outputFile.close()
def generate_from_caldav(event: caldav.Event): def gt(dt_str): dt, _, us= dt_str.partition(".") dt= datetime.strptime("{} +0000".format(dt), "%Y-%m-%dT%H:%M:%S %z") return dt def obj_hook(obj): if '__type__' in obj and obj['__type__']=='PnPParty': return PnPParty(gt(obj['date']), obj['gm'], obj['players'], obj['slot'], obj['max_players'] ) subcomponents = Calendar.from_ical(event.data).subcomponents if len(subcomponents) == 1: tmp_event = subcomponents[0] json_string = tmp_event.get('DESCRIPTION') try: obj = loads(json_string, object_hook=obj_hook) except TypeError as e: print('The JSON was malformed: {}'.format(e)) return None else: print('There are {} submodules, we need exactly 1'.format(len(subcomponents))) return None obj.event = event obj.title = tmp_event.get('SUMMARY') if not tmp_event.get("dtstart").dt == obj.date : print(obj.date, tmp_event.get("dtstart").dt) logging.warning("json date and dtstart are not equal.") obj.date = tmp_event.get("dtstart").dt return obj
def next_occurrence(self): # if not messages have been queued yet, then the next occurrence # is the start time next_occur = None if (not self.last_occurrence_in_utc): next_occur = self.start_datetime_in_utc.datetime next_expire = arrow.get(next_occur).replace(minutes=+10) if self.end_datetime_in_utc < next_expire: next_expire = self.end_datetime_in_utc return next_occur, next_expire else: start = self.start_datetime_in_utc.datetime cal = Calendar.from_ical(self.ical) if cal.get('RRULE'): rrule = cal.get('RRULE').to_ical() rule = rrulestr(rrule, dtstart=start) next_after_now = rule.after(self.compare_datetime_in_utc or arrow.utcnow().datetime) else: next_after_now = None if not next_after_now: logging.info('No next_after_now, so next_occur=N/A') return 'N/A', self.compare_datetime_in_utc or arrow.utcnow() next_before_now = rule.before(next_after_now) if next_before_now and \ (self.last_occurrence_in_utc > next_before_now): next_occur = next_after_now else: next_occur = next_before_now rule = rrulestr(rrule, dtstart=next_occur) expires = rule.after(next_occur) if not expires: return 'N/A', arrow.utcnow().replace(minutes=+10) if (expires > self.end_datetime_in_utc): expires = self.end_datetime_in_utc return arrow.get(next_occur), arrow.get(expires)
def url_to_ics(): #fetching data from url and transform to .ics now = datetime.utcnow() #provide a universal standardised reference point now.replace(tzinfo=pytz.utc) #accounting for daylight savings time today = datetime.utcnow().replace(tzinfo=pytz.utc).date() urls = [URL.strip() ] #strip url combined_cal = Calendar() #create calendar for url in urls: req = requests.get(url) if req.status_code != 200: #error fetching url print("Error {} fetching {}: {}" .format(url, req.status_code, req.text)) continue cal = Calendar.from_ical(req.text) for event in cal.walk("VEVENT"): end = event.get('dtend') if end: if hasattr(end.dt, 'date'): date = end.dt.date() else: date = end.dt if date >= today or 'RRULE' in event: copied_event = Event() for attr in event: if type(event[attr]) is list: for element in event[attr]: copied_event.add(attr, element) else: copied_event.add(attr, event[attr]) combined_cal.add_component(copied_event) with open("timetable.ics", "wb") as f: f.write(combined_cal.to_ical())
def import_ics(self): ics = base64.b64decode(self.ics_file) lines = [] for event in Calendar.from_ical(ics).walk("vevent"): dtend = event.get("dtend").dt dtstart = event.get("dtstart").dt day_count = (dtend - dtstart).days if day_count > 1: for dt in (dtstart + timedelta(n) for n in range(day_count)): lines.extend( [ ( 0, 0, {"name": event.get("summary"), "date": dt.strftime(DF)}, ) ] ) else: lines.extend( [ ( 0, 0, { "name": event.get("summary"), "date": dtstart.strftime(DF), }, ) ] ) if lines: holidays = self.env["hr.holidays.public"].browse( self._context.get("active_id", []) ) holidays.write({"line_ids": lines})
def parse_events(content, start=None, end=None): """ Query the events occurring in a given time range. :param content: iCal URL/file content as String :param start: start date for search, default today :param end: end date for search :return: events as list """ if not start: start = now() if not end: end = start + default_span if len(content) == 0: raise ValueError('Content is invalid!') calendar = Calendar.from_ical(content) start = normalize(start) end = normalize(end) found = [] for component in calendar.walk(): if component.name == "VEVENT": if component.get('rrule'): es = create_recurring_events(start, end, component) if es: found += es else: e = create_event(component) if e.end >= start and e.start <= end: found.append(e) return found