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
def create_calendar(email: str, credential_file: str) -> GoogleCalendar: return GoogleCalendar( email, credentials_path=credential_file, token_path=os.path.join(os.environ["HOME"], ".credentials", f"{email}.pickle"), )
def setup(calendar_settings_): global calendar, calendar_settings calendar_settings = calendar_settings_ load_dotenv() calendar_id = os.getenv('CALENDAR_ID') calendar_credentials = os.getenv('CALENDAR_CREDENTIALS_FILE') calendar = GoogleCalendar(calendar_id, credentials_path=calendar_credentials)
def test_get_default_credentials_path_not_exist(self): self.assertFalse( path.exists(path.join(path.expanduser('~'), '.credentials'))) self.assertEqual( path.join(path.expanduser('~'), '.credentials/credentials.json'), GoogleCalendar._get_default_credentials_path()) self.assertTrue( path.exists(path.join(path.expanduser('~'), '.credentials')))
def get_calendar(name): """Wrapper for GoogleCalendar""" return GoogleCalendar( name, credentials_path=PATH_GCAL_JSON, token_path=PATH_TOKEN_LOCAL, read_only=True, )
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
def get_cal() -> GoogleCalendar: # Since we're using a serivce account # and gcsa doesn't support service accounts # I made a workaround if not check_valid_creds(GAPP_TOK): gen_service_token(GAPP_TOK, GAPP_CREDS) return GoogleCalendar( calendar=GCAL_ID, read_only=True, token_path=GAPP_TOK )
def refresh_calendar(self): self.calendar = [] for calendar in self.calendars: calendar_project = fetch_project_id(calendar['name'], self.project_id) logger.info(f'Getting calendar: "{calendar}"') events = list( GoogleCalendar(calendar['id'], credentials_path=os.path.join( os.path.dirname(__file__), '.credentials', 'credentials.json'))) for event in events: setattr(event, 'calendar_project', calendar_project) self.calendar += events
def parse_google_calendar(email_id: str, start_time: datetime.datetime, end_time: datetime.datetime) -> List[CalendarEvent]: """ Parse google calendar and return events. End time is not inclusive. """ cal = GoogleCalendar(email_id) events = [] for ev in cal[start_time:end_time]: name = ev.summary start_time = ev.start end_time = ev.end if not ev.attendees: # This is likely a personal event response_status: Optional[str] = "accepted" attendees = [email_id] else: attendee = py_.find(ev.attendees, lambda at: at.email == email_id) try: if attendee.response_status == "needsAction": response_status = None else: response_status = attendee.response_status except AttributeError: response_status = None attendees = [a.email for a in ev.attendees] events.append(CalendarEvent( name=name, start_time=start_time, end_time=end_time, attendees=attendees, response_status=response_status )) return events
def getCalendar(): return GoogleCalendar( "*****@*****.**", credentials_path=".credentials/credentials.json")
next_assignment_date = datetime.datetime.strftime( next_assignment_date, "%Y-%m-%d") # assignment due date needs to be later than term start date # append to list if str(next_assignment_date) >= term_start_date: course_name.append(next_item["name"]) assignment_due_date.append(next_assignment_date) course_ids.append(next_item["course_id"]) # print(course_name) # print(assignment_due_date) # google calendar credentials user_email = "*****@*****.**" google_cred = os.getenv("GOOGLE_CALENDAR_CRED") gc = GoogleCalendar(credentials_path=google_cred) calendar = GoogleCalendar(user_email) # for loop all lists - and extract matching key values from course_ids for name, due_date, course_id in zip(course_name, assignment_due_date, course_ids): for key, value in course_dict.items(): if course_id == int(key): # print(due_date.split("-")[0]) # print(due_date.split("-")[1]) # print(due_date.split("-")[2]) final_name = name + " " + value start = datetime.datetime(int(due_date.split("-")[0]), int(due_date.split("-")[1]), int(due_date.split("-")[2])) event = Event(final_name, start=start,
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 test_with_given_credentials(self): GoogleCalendar(credentials=MockToken(valid=True)) self.assertFalse(self.from_client_secrets_file_patcher.called)
def get_calendars(): calendars = {} for email in redis_keys('creds'): credentials = oauth2client.client.OAuth2Credentials.from_json(redis_json_get(f'creds:{email}')) calendars[email] = GoogleCalendar(credentials) return calendars
def test_get_default_credentials_path_exist(self): self.fs.create_dir(path.join(path.expanduser('~'), '.credentials')) self.assertEqual( path.join(path.expanduser('~'), '.credentials/credentials.json'), GoogleCalendar._get_default_credentials_path())
def test_with_given_credentials_expired(self): gc = GoogleCalendar(credentials=MockToken(valid=False)) self.assertTrue(gc.credentials.valid) self.assertFalse(gc.credentials.expired)
def test_get_token_valid(self): gc = GoogleCalendar(token_path=self.valid_token_path) self.assertTrue(gc.credentials.valid) self.assertFalse(self.from_client_secrets_file_patcher.called)
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))
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)
def test_get_token_invalid_refresh(self): gc = GoogleCalendar(credentials_path=self.credentials_path) self.assertTrue(gc.credentials.valid) self.assertFalse(gc.credentials.expired) self.assertTrue(self.from_client_secrets_file_patcher.called)
from gcsa.google_calendar import GoogleCalendar # https://github.com/jignesh13/googlecalendar # https://github.com/kuzmoyev/beautiful-date calendar = GoogleCalendar('*****@*****.**') for event in calendar: print(event)
# %% [markdown] # ## Personal Calendar for Signups # # [email protected] # %% from gcsa.event import Event as gcEvent from gcsa.google_calendar import GoogleCalendar import socket socket.setdefaulttimeout(300) # 5 minutes EMAIL_FOR_CAL = '*****@*****.**' calendar = GoogleCalendar(EMAIL_FOR_CAL) # %% 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
calendar_file.chmod(0o400) local_cache = LocalCache() to_be_added: Dict[str, CalEvent] = {} to_be_removed: List[CalEvent] = [] now = datetime.datetime.now(datetime.timezone.utc) # ingest the remote events from the Google Calendars for calendar in calendar_file.read_text().strip().split("\n"): if not calendar: continue 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
def getCalendar(self, calendar_id): calendar = GoogleCalendar(calendar_id, './credentials.json') # room 6164 return calendar
from gcc_app.global_utils import ReaderTXT db = declarative_base() async def create_async_session(): engine = create_async_engine(SQLALCHEMY_DATABASE_URI, echo=True) async_session = sessionmaker(engine, expire_on_commit=False, class_=AsyncSession) return async_session() storage = RedisStorage(**REDIS_URI) calendar = GoogleCalendar(EMAIL_GOOGLE_CALENDAR) bot = Bot(token=TOKEN_BOT) dp = Dispatcher(bot, storage=storage) dp.middleware.setup(LoggingMiddleware()) BAD_WORDS = ReaderTXT(BAD_WORDS_FILE).read_txt_into_frozenset() async def set_commands(bot: Bot): commands = [ BotCommand(command=COMMAND_CREATE_EVENT[0], description=COMMAND_CREATE_EVENT[1]), BotCommand(command=COMMAND_HELP[0], description=COMMAND_HELP[1]), BotCommand(command=COMMAND_START[0], description=COMMAND_START[1]), BotCommand(command=COMMAND_TEST[0], description=COMMAND_TEST[1]),