コード例 #1
0
def get_notify_embeds(cal: GoogleCalendar, start: Arrow, end: Arrow) -> List[Tuple[Arrow, Embed]]:
    events_res = cal.get_events(
        time_min=start.datetime,
        time_max=end.datetime
    )

    embeds = []

    for event in events_res:
        embed = event2embed(event)

        if len(event.reminders) == 0:
            # One Notification at the time of the event
            pingTime = arrow.get(event.start)
            # if pingTime.is_between(start, end, '[)'):
            #     yield (pingTime, embed,)

            # One notification 10 mins before
            pingTime = pingTime.shift(minutes=-10)
            if pingTime.is_between(start, end, '[)'):
                embeds.append((pingTime, embed,))

        # There's currently a bug in gcsa
        # event.reminders is always empty
        # so this never gets triggered
        for r in event.reminders:
            if isinstance(r, PopupReminder):
                min_shift = -1*r.minutes_before_start
                pingTime = arrow.get(event.start).shift(minutes=min_shift)
                if pingTime.is_between(start, end, '[)'):
                    embeds.append((pingTime, embed,))

    return embeds
コード例 #2
0
def get_embeds(cal: GoogleCalendar, start: Arrow, end: Arrow) -> List[Embed]:
    events_res = cal.get_events(
        time_min=start.datetime,
        time_max=end.datetime,
        order_by="startTime"
    )

    events = list(map(lambda e: event2embed(event), events_res))

    return events
コード例 #3
0
ファイル: model.py プロジェクト: basilthebeagles/calendarText
def getEventsOneDate(date, calendarChoice):

    print("in model")

    bigRawEventTuple = []

    bigRawAllDayEventTuple = []

    bigRawNotAllDayEventTuple = []

    print(calendarChoice)

    index = 0

    for name in calendarChoice:

        index += 1
        print(index)

        print(name)

        calendar = GoogleCalendar(name, creds)

        print(calendar)

        eventObjectArray = calendar.get_events(date,
                                               date,
                                               order_by='startTime')

        print(str(eventObjectArray))

        print('' 'h')

        for event in eventObjectArray:

            print(str(event))

            rawEvent = []

            rawEvent.append(str(event.summary))
            rawEvent.append(str(event.location))

            print("in event")

            rawEvent.append(event.start.time())

            rawEvent.append(event.end.time())

            print(rawEvent)

            if len(str(event.start)) == 10:

                bigRawAllDayEventTuple.append(rawEvent)
                print("appending1")
            else:
                bigRawNotAllDayEventTuple.append(rawEvent)
                print("appending2")

    allDayEvents = sorted(bigRawAllDayEventTuple)

    notAllDayEvents = sorted(bigRawNotAllDayEventTuple,
                             key=operator.itemgetter(1, 2))

    bigRawEventTuple = allDayEvents + notAllDayEvents

    return (allDayEvents, notAllDayEvents)
コード例 #4
0
df.index.max()

# %% [markdown]
# ## Read Events in Calendar which Are Within Timeframe of RGDB Data
#
# Add one day to timeframe to compensate for unpredictable time zone handling.
#
# Note IDs of existing events so we don't re-create them.

# %%
df['cal_id'] = None
df['event_obj'] = None
df['found'] = False

for event in calendar.get_events(
        time_min=df.index.min() - datetime.timedelta(days=1),
        time_max=df.index.max() + datetime.timedelta(days=1),
        timezone='UTC'):

    df.loc[(df['Name'] == event.summary) & (df.index == event.start),
           ['found', 'cal_id', 'event_obj']] = [True, event.event_id, event]

    #if event.start in df.loc[df['Name'] == event.summary].index:
    #    df.at[event.start, 'cal_id'] = event.event_id
    #    df.at[event.start, 'event_obj'] = event
    #    print('found ', event, event.timezone, event.event_id)

# %%
df.loc[df['found'] == False]

# %%
for index, row in df.iterrows():
コード例 #5
0
ファイル: gcal-sync.py プロジェクト: jdost/configs
        try:
            cal = GoogleCalendar(
                calendar,
                credentials_path=XDG_CONFIG_HOME / "calcurse/credentials.json",
                read_only=True,
            )
        except RefreshError:
            token = XDG_CONFIG_HOME / "calcurse/token.pickle"
            if token.exists():
                token.unlink()
            print("Token expired.  Re-auth manually...")
            sys.exit(1)

        for raw_event in cal.get_events(now,
                                        now + WINDOW,
                                        single_events=True,
                                        order_by="startTime"):
            event = CalEvent(calendar, raw_event)
            to_be_added[event._id] = event

    # Collect anything that *was* on the remote previously but is no longer
    for key in local_cache.events - set(to_be_added.keys()):
        to_be_removed.append(local_cache[key])
        local_cache.remove(key)

    # Check all events that were previously added
    for key in local_cache.events & set(to_be_added.keys()):
        # check if the event was updated on the remote, if it is, remove the
        # old and re-add the updated event
        if local_cache[key].fingerprint != to_be_added[key].fingerprint:
            to_be_removed.append(local_cache[key])
コード例 #6
0
class TestGoogleCalendarAPI(TestCase):
    def setUp(self):
        self.build_patcher = patch('googleapiclient.discovery.build',
                                   return_value=MockService())
        self.build_patcher.start()

        self.gc = GoogleCalendar(credentials=MockToken(valid=True))

    def tearDown(self):
        self.build_patcher.stop()

    def test_get_events_default(self):
        events = list(self.gc.get_events())
        self.assertEqual(len(events), 10)
        self.assertFalse(any(e.is_recurring_instance for e in events))

        events = list(self.gc)
        self.assertEqual(len(events), 10)
        self.assertFalse(any(e.is_recurring_instance for e in events))

    def test_get_events_time_limits(self):
        time_min = insure_localisation(D.today()[:] + 5 * days)
        events = list(self.gc.get_events(time_min=time_min))
        self.assertEqual(len(events), 6)
        self.assertTrue(all(e.start >= time_min for e in events))

        time_min = insure_localisation(D.today()[:] + 5 * days)
        events = list(self.gc[time_min])
        self.assertEqual(len(events), 6)
        self.assertTrue(all(e.start >= time_min for e in events))

        time_max = insure_localisation(D.today()[:] + 1 * years + 7 * days)
        events = list(self.gc.get_events(time_max=time_max))
        self.assertEqual(len(events), 11)
        self.assertTrue(all(e.end < time_max for e in events))

        time_max = insure_localisation(D.today()[:] + 7 * days)
        events = list(self.gc.get_events(time_max=time_max))
        self.assertEqual(len(events), 7)
        self.assertTrue(all(e.end < time_max for e in events))

        events = list(self.gc.get_events(time_min=time_min, time_max=time_max))
        self.assertEqual(len(events), 2)
        self.assertTrue(
            all(time_min <= e.start and e.end < time_max for e in events))

        events = list(self.gc[time_min:time_max])
        self.assertEqual(len(events), 2)
        self.assertTrue(
            all(time_min <= e.start and e.end < time_max for e in events))

        time_min = D.today() + 5 * days
        time_max = D.today() + 7 * days
        events = list(self.gc.get_events(time_min=time_min, time_max=time_max))
        self.assertEqual(len(events), 3)

        time_min = insure_localisation(time_min[0:0])
        time_max = insure_localisation(time_max[23:59:59])
        self.assertTrue(
            all(time_min <= e.start and e.end < time_max for e in events))

        with self.assertRaises(NotImplementedError):
            _ = self.gc[5]
        with self.assertRaises(ValueError):
            _ = self.gc[5:10]

    def test_get_events_single_events(self):
        events = list(self.gc.get_events(single_events=True))
        self.assertEqual(len(events), 19)
        self.assertTrue(
            all(e.is_recurring_instance for e in events
                if e.summary == 'Recurring event'))

        events = list(self.gc.get_events(single_events=False))
        self.assertEqual(len(events), 10)
        self.assertTrue(
            all(not e.is_recurring_instance for e in events
                if e.summary == 'Recurring event'))

        with self.assertRaises(ValueError):
            # can only be used with single events
            list(self.gc.get_events(order_by='startTime'))

    def test_get_events_order_by(self):
        events = list(self.gc.get_events(order_by='updated'))
        self.assertEqual(len(events), 10)
        self.assertEqual(events[0].id, min(events, key=lambda e: e.updated).id)
        self.assertEqual(events[-1].id,
                         max(events, key=lambda e: e.updated).id)

        events = list(self.gc[::'updated'])
        self.assertEqual(len(events), 10)
        self.assertEqual(events[0].id, min(events, key=lambda e: e.updated).id)
        self.assertEqual(events[-1].id,
                         max(events, key=lambda e: e.updated).id)

        events = list(self.gc[::'startTime'])
        self.assertEqual(len(events), 19)
        self.assertEqual(events[0].id, min(events, key=lambda e: e.start).id)
        self.assertEqual(events[-1].id, max(events, key=lambda e: e.start).id)

        events = list(
            self.gc.get_events(order_by='startTime', single_events=True))
        self.assertEqual(len(events), 19)
        self.assertEqual(events[0].id, min(events, key=lambda e: e.start).id)
        self.assertEqual(events[-1].id, max(events, key=lambda e: e.start).id)

    def test_get_events_query(self):
        events = list(
            self.gc.get_events(query='test4',
                               time_max=D.today()[:] + 2 * years))
        self.assertEqual(len(events), 2)  # test4 and test42

        events = list(
            self.gc.get_events(query='Jo', time_max=D.today()[:] + 2 * years))
        self.assertEqual(len(events), 2)  # with John and Josh

        events = list(
            self.gc.get_events(query='Josh',
                               time_max=D.today()[:] + 2 * years))
        self.assertEqual(len(events), 1)

        events = list(
            self.gc.get_events(query='Frank',
                               time_max=D.today()[:] + 2 * years))
        self.assertEqual(len(events), 1)

    def test_get_recurring_instances(self):
        events = list(self.gc.get_instances(recurring_event='event_id_1'))
        self.assertEqual(len(events), 9)
        self.assertTrue(all(e.id.startswith('event_id_1') for e in events))

        recurring_event = Event('recurring event',
                                D.today()[:],
                                event_id='event_id_2')
        events = list(self.gc.get_instances(recurring_event=recurring_event))
        self.assertEqual(len(events), 4)
        self.assertTrue(all(e.id.startswith('event_id_2') for e in events))