Calendar class just oop approach to the calendar api methods

gapi/apis/calendar_api/__init__.py

@@ -1,5 +1,9 @@
-import os
+from .models import Calendar, Event
+from .calendar_api import calendar_api
 
 
-from .models import Event
-from .calendar_api import calendar_api
+def get_calendars_from_api(api: calendar_api):
+    ret = dict()
+    for calendar_name in api.ids.keys():
+        ret[calenadr_name] = Calendar(api, calendar_name)
+    return ret

gapi/apis/calendar_api/calendar_api.py

@@ -1,9 +1,11 @@
+import datetime
 import os
 
 from googleapiclient.errors import HttpError
 
 import gapi
 from gapi.apis.base_api import API
+from .utils import to_dateTime
 
 APPLICATION_NAME = "Google Calendar API Python"
 
@@ -74,27 +76,46 @@ class calendar_api(API):
             page_token = calendar_list.get("nextPageToken")
         return cl
 
-    def get_events(self, cal_id):
+    def get_events(self, cal_id, **params):
+        """Return events with params"""
         service = self.service
         try:
             cal_id = self.ids[cal_id]
         except KeyError:
             pass
         page_token = None
-        ret = []
-        while True:
+        first = True
+        while page_token is not None or first:
+            first = False
             event_service = service.events()
             events = event_service.list(
-                calendarId=cal_id, pageToken=page_token
+                calendarId=cal_id, pageToken=page_token, **params
             ).execute()
-            ret += events["items"]
+            for event in events["items"]:
+                yield event
             page_token = events.get("nextPageToken")
-            if not page_token:
-                break
-        return ret
+
+    def get_events_in_range(
+        self,
+        cal_id,
+        start_date: datetime.datetime = None,
+        end_date: datetime.datetime = None,
+    ):
+        """Returns events in between the given time range"""
+        if start_date is not None:
+            start_date = to_dateTime(start_date)
+        if end_date is not None:
+            end_date = to_dateTime(end_date)
+
+        self.get_events(self, cal_id=cal_id, timeMin=start_date, timeMax=end_date)
 
     def get_event_by_id(self, cal_id, event_id):
         """Retrieves event from cal_id and event_id"""
         service = self.service
         event_service = service.events()
         return event_service.get(calendarId=cal_id, eventId=event_id).execute()
+
+    def delete_event(self, cal_id, event_id):
+        service = self.service
+        event_service = service.events()
+        return event_service.delete(calendarId=cal_id, eventId=event_id).execute()

gapi/apis/calendar_api/models.py

@@ -18,36 +18,6 @@ class weekdays(IntEnum):
     SAT = 5
 
 
-class Calendar:
-    """Model for representing a Google calendar"""
-
-    def __init__(self, api: calendar_api, calendar_id):
-        self.api = api
-
-        if calendar_id in api.ids.keys():
-            self.name = calendar_id
-            self.calendar_id = self.api.ids[self.name]
-        elif calendar_id in api.ids.values():
-            self.name = self.api.calendars[calendar_id]["summary"]
-            self.id = calendar_id
-        else:
-            raise ValueError("Non-existent calendar specified")
-        self.calendar_id = calendar_id
-
-    def update_or_add_0event(self, event: Event):
-        event.upload(self.api, self.calendar_id)
-
-    def search_events(self, event_name):
-        pass
-
-
-def calendar_dict(api: calendar_api):
-    return dict(
-        (calendar_name, Calendar(api, calendar_name))
-        for calendar_name in api.ids.keys()
-    )
-
-
 class Event:
     """Model for a calendar event that can be uploaded"""
 
@@ -156,5 +126,60 @@ class Event:
         self.id = event_id
         return event_id
 
-    def delete(self, api: calendar_api):
-        pass
+
+class Calendar:
+    """Model for representing a Google calendar"""
+
+    def __init__(self, api: calendar_api, calendar_id):
+        self.api = api
+
+        if calendar_id in api.ids.keys():
+            self.name = calendar_id
+            self.calendar_id = self.api.ids[self.name]
+        elif calendar_id in api.ids.values():
+            self.name = self.api.calendars[calendar_id]["summary"]
+            self.id = calendar_id
+        else:
+            raise ValueError("Non-existent calendar specified")
+        self.calendar_id = calendar_id
+
+    def update_or_add_event(self, event: Event):
+        event.upload(self.api, self.calendar_id)
+
+    def get_events(
+        self, start: datetime.datetime = None, end: datetime.datetime = None
+    ):
+        return (
+            Event(event_representation)
+            for event_representation in self.api.get_events_in_range(
+                self.cal_id, start, end
+            )
+        )
+
+    def delete_event(self, event: Event):
+        if event.id is not None:
+            return self.api.delete_event(self.calendar_id, event.id)
+
+    def search_events(
+        self, event_name_regex=None, event_description_regex=None, start=None, end=None
+    ):
+        for event in self.get_events(start, end):
+            will_yield = False
+            if event_name_regex is not None:
+                will_yield = re.search(event_name_regex, Event.name) is not None
+
+            if event_name_regex is not None:
+                will_yield = (
+                    re.search(event_description_regex, Event.description) is not None
+                    or will_yield  # noqa
+                )
+
+            if will_yield:
+                yield event
+
+
+def calendar_dict(api: calendar_api):
+    return dict(
+        (calendar_name, Calendar(api, calendar_name))
+        for calendar_name in api.ids.keys()
+    )