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]),
