google-api-client-wrapper 1.1.2__tar.gz → 1.1.4__tar.gz

{google_api_client_wrapper-1.1.2 → google_api_client_wrapper-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-api-client-wrapper
-Version: 1.1.2
+Version: 1.1.4
 Summary: A comprehensive Python wrapper for Google APIs, providing clean and intuitive access to Gmail, Google Drive, Google Calendar, and Google Tasks services.
 Author-email: Dagmawi Molla <dagmawishewadeg@gmail.com>
 License: MIT License

{google_api_client_wrapper-1.1.2 → google_api_client_wrapper-1.1.4}/google_api_client_wrapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-api-client-wrapper
-Version: 1.1.2
+Version: 1.1.4
 Summary: A comprehensive Python wrapper for Google APIs, providing clean and intuitive access to Gmail, Google Drive, Google Calendar, and Google Tasks services.
 Author-email: Dagmawi Molla <dagmawishewadeg@gmail.com>
 License: MIT License

{google_api_client_wrapper-1.1.2 → google_api_client_wrapper-1.1.4}/google_client/services/calendar/types.py

@@ -50,9 +50,12 @@ class CalendarEvent(BaseModel):
     start: Optional[datetime] = Field(None, description="The start time of the event as a datetime object")
     end: Optional[datetime] = Field(None, description="The end time of the event as a datetime object")
     html_link: Optional[str] = Field(None, description="A hyperlink to the event on Google Calendar")
-    attendees: List[Attendee] = Field(default_factory=list, description="A list of Attendee objects representing the people invited to the event")
-    recurrence: List[str] = Field(default_factory=list, description="A list of strings defining the recurrence rules for the event in RFC 5545 format")
-    recurring_event_id: Optional[str] = Field(None, description="The ID of the recurring event if this event is part of a series")
+    attendees: List[Attendee] = Field(default_factory=list,
+                                      description="A list of Attendee objects representing the people invited to the event")
+    recurrence: List[str] = Field(default_factory=list,
+                                  description="A list of strings defining the recurrence rules for the event in RFC 5545 format")
+    recurring_event_id: Optional[str] = Field(None,
+                                              description="The ID of the recurring event if this event is part of a series")
     creator: Optional[str] = Field(None, description="The creator of the event")
     organizer: Optional[str] = Field(None, description="The organizer of the event")
     status: Optional[str] = Field("confirmed", description="The status of the event (confirmed, tentative, cancelled)")
@@ -164,7 +167,7 @@ class CalendarEvent(BaseModel):
             Dictionary representation suitable for API calls.
         """
         event_dict = {}
-        
+
         if self.event_id:
             event_dict["id"] = self.event_id
         if self.summary:
@@ -173,6 +176,8 @@ class CalendarEvent(BaseModel):
             event_dict["description"] = self.description
         if self.location:
             event_dict["location"] = self.location
+        if self.start:
+            event_dict["time"] = convert_datetime_to_readable(self.start, self.end)
         if self.html_link:
             event_dict["htmlLink"] = self.html_link
         if self.recurrence:
@@ -185,10 +190,10 @@ class CalendarEvent(BaseModel):
             event_dict["organizer"] = self.organizer
         if self.status:
             event_dict["status"] = self.status
-            
+
         if self.attendees:
             event_dict["attendees"] = [attendee.to_dict() for attendee in self.attendees]
-            
+
         return event_dict
 
     def __repr__(self):
@@ -210,46 +215,45 @@ class TimeSlot(BaseModel):
     """
     start: datetime = Field(..., description="Start datetime of the time slot")
     end: datetime = Field(..., description="End datetime of the time slot")
-    
+
     def model_post_init(self, __context__: Any):
         if self.start >= self.end:
             raise ValueError("Start time must be before end time")
-    
+
     def duration(self) -> int:
         """
         Calculate the duration of the time slot in minutes.
-        
+
         Returns:
             Duration in minutes
         """
         return int((self.end - self.start).total_seconds() / 60)
-    
+
     def overlaps_with(self, other: "TimeSlot") -> bool:
         """
         Check if this time slot overlaps with another time slot.
-        
+
         Args:
             other: Another TimeSlot to check for overlap
-            
+
         Returns:
             True if the time slots overlap, False otherwise
         """
         return self.start < other.end and self.end > other.start
-    
+
     def contains_time(self, time_point: datetime) -> bool:
         """
         Check if a specific datetime falls within this time slot.
-        
+
         Args:
             time_point: Datetime to check
-            
+
         Returns:
             True if the time point is within this slot, False otherwise
         """
         return self.start <= time_point < self.end
-    
-    def __str__(self):
 
+    def __str__(self):
         return convert_datetime_to_readable(
             convert_datetime_to_local_timezone(self.start),
             convert_datetime_to_local_timezone(self.end)
@@ -262,86 +266,88 @@ class FreeBusyResponse(BaseModel):
     """
     start: datetime = Field(..., description="Start time of the query")
     end: datetime = Field(..., description="End time of the query")
-    calendars: Dict[str, List[TimeSlot]] = Field(default_factory=dict, description="Dictionary mapping calendar IDs to their busy periods")
-    errors: Dict[str, str] = Field(default_factory=dict, description="Dictionary mapping calendar IDs to any errors encountered")
-    
+    calendars: Dict[str, List[TimeSlot]] = Field(default_factory=dict,
+                                                 description="Dictionary mapping calendar IDs to their busy periods")
+    errors: Dict[str, str] = Field(default_factory=dict,
+                                   description="Dictionary mapping calendar IDs to any errors encountered")
+
     def get_busy_periods(self, calendar_id: str = "primary") -> List[TimeSlot]:
         """
         Get busy periods for a specific calendar.
-        
+
         Args:
             calendar_id: Calendar ID to get busy periods for
-            
+
         Returns:
             List of TimeSlot objects representing busy periods
         """
         return self.calendars.get(calendar_id, [])
-    
+
     def is_time_free(self, time_point: datetime, calendar_id: str = "primary") -> bool:
         """
         Check if a specific time is free in the given calendar.
-        
+
         Args:
             time_point: Datetime to check
             calendar_id: Calendar ID to check
-            
+
         Returns:
             True if the time is free, False if busy
         """
         if not (self.start <= time_point <= self.end):
             raise ValueError("Time point is outside the queried range")
-            
+
         busy_periods = self.get_busy_periods(calendar_id)
         return not any(period.contains_time(time_point) for period in busy_periods)
-    
+
     def is_slot_free(self, slot: TimeSlot, calendar_id: str = "primary") -> bool:
         """
         Check if an entire time slot is free in the given calendar.
-        
+
         Args:
             slot: TimeSlot to check
             calendar_id: Calendar ID to check
-            
+
         Returns:
             True if the entire slot is free, False if any part is busy
         """
         busy_periods = self.get_busy_periods(calendar_id)
         return not any(period.overlaps_with(slot) for period in busy_periods)
-    
+
     def get_free_slots(self, duration_minutes: int = 60, calendar_id: str = "primary") -> List[TimeSlot]:
         """
         Get all free time slots of a specified duration within the queried range.
-        
+
         Args:
             duration_minutes: Minimum duration for free slots in minutes
             calendar_id: Calendar ID to get free slots for
-            
+
         Returns:
             List of TimeSlot objects representing available time slots
         """
         from ...utils.datetime import current_datetime_local_timezone
-        
+
         busy_periods = sorted(self.get_busy_periods(calendar_id), key=lambda x: x.start)
         free_slots = []
-        
+
         # Start from the beginning of the range or current time (whichever is later)
         current_time = max(self.start, current_datetime_local_timezone())
-        
+
         # Check time before first busy period
         if busy_periods and current_time < busy_periods[0].start:
             gap_duration = (busy_periods[0].start - current_time).total_seconds() / 60
             if gap_duration >= duration_minutes:
                 free_slots.append(TimeSlot(start=current_time, end=busy_periods[0].start))
-        
+
         # Check gaps between busy periods
         for i in range(len(busy_periods) - 1):
             gap_start = busy_periods[i].end
             gap_end = busy_periods[i + 1].start
             gap_duration = (gap_end - gap_start).total_seconds() / 60
-            
+
             if gap_duration >= duration_minutes:
                 free_slots.append(TimeSlot(start=gap_start, end=gap_end))
-        
+
         # Check time after last busy period
         if busy_periods:
             gap_start = busy_periods[-1].end
@@ -354,13 +360,13 @@ class FreeBusyResponse(BaseModel):
             gap_duration = (self.end - current_time).total_seconds() / 60
             if gap_duration >= duration_minutes:
                 free_slots.append(TimeSlot(start=current_time, end=self.end))
-        
+
         return free_slots
-    
+
     def has_errors(self) -> bool:
         """
         Check if there were any errors in the freebusy query.
-        
+
         Returns:
             True if there were errors, False otherwise
         """

{google_api_client_wrapper-1.1.2 → google_api_client_wrapper-1.1.4}/google_client/services/calendar/utils.py

@@ -1,6 +1,8 @@
 from datetime import datetime
 from typing import Optional, List, Dict, Any
 
+import tzlocal
+
 from .types import CalendarEvent, Attendee, TimeSlot, FreeBusyResponse
 from .constants import (
     MAX_SUMMARY_LENGTH, MAX_DESCRIPTION_LENGTH, MAX_LOCATION_LENGTH,
@@ -8,7 +10,6 @@ from .constants import (
 )
 from ...utils.datetime import convert_datetime_to_iso
 
-
 # Import from shared utilities
 from ...utils.validation import is_valid_email, validate_text_field, sanitize_header_value
 
@@ -22,16 +23,16 @@ def validate_datetime_range(start: Optional[datetime], end: Optional[datetime])
 def parse_datetime_from_api(datetime_data: Dict[str, Any]) -> Optional[datetime]:
     """
     Parse datetime from Google Calendar API response.
-    
+
     Args:
         datetime_data: Dictionary containing dateTime or date fields
-        
+
     Returns:
         Parsed datetime object or None if parsing fails
     """
     if not datetime_data:
         return None
-        
+
     try:
         if datetime_data.get("dateTime"):
             # Handle timezone-aware datetime
@@ -44,22 +45,22 @@ def parse_datetime_from_api(datetime_data: Dict[str, Any]) -> Optional[datetime]
             return datetime.strptime(datetime_data["date"], "%Y-%m-%d")
     except (ValueError, TypeError):
         pass
-        
+
     return None
 
 
 def parse_attendees_from_api(attendees_data: List[Dict[str, Any]]) -> List[Attendee]:
     """
     Parse attendees from Google Calendar API response.
-    
+
     Args:
         attendees_data: List of attendee dictionaries from API
-        
+
     Returns:
         List of Attendee objects
     """
     attendees = []
-    
+
     for attendee_data in attendees_data:
         email = attendee_data.get("email")
         if email and is_valid_email(email):
@@ -67,7 +68,7 @@ def parse_attendees_from_api(attendees_data: List[Dict[str, Any]]) -> List[Atten
                 response_status = attendee_data.get("responseStatus")
                 if response_status and response_status not in VALID_RESPONSE_STATUSES:
                     response_status = None
-                    
+
                 attendees.append(Attendee(
                     email=email,
                     display_name=attendee_data.get("displayName"),
@@ -75,17 +76,17 @@ def parse_attendees_from_api(attendees_data: List[Dict[str, Any]]) -> List[Atten
                 ))
             except ValueError:
                 pass
-                
+
     return attendees
 
 
 def from_google_event(google_event: Dict[str, Any]) -> CalendarEvent:
     """
     Create a CalendarEvent instance from a Google Calendar API response.
-    
+
     Args:
         google_event: Dictionary containing event data from Google Calendar API
-        
+
     Returns:
         CalendarEvent instance populated with the data from the dictionary
     """
@@ -96,31 +97,31 @@ def from_google_event(google_event: Dict[str, Any]) -> CalendarEvent:
         description = google_event.get("description", "").strip() if google_event.get("description") else None
         location = google_event.get("location", "").strip() if google_event.get("location") else None
         html_link = google_event.get("htmlLink")
-        
+
         # Parse datetimes
         start = parse_datetime_from_api(google_event.get("start", {}))
         end = parse_datetime_from_api(google_event.get("end", {}))
-        
+
         # Parse attendees
         attendees_data = google_event.get("attendees", [])
         attendees = parse_attendees_from_api(attendees_data)
-        
+
         # Parse recurrence
         recurrence = google_event.get("recurrence", [])
         recurring_event_id = google_event.get("recurringEventId")
-        
+
         # Parse creator and organizer
         creator_data = google_event.get("creator", {})
         creator = creator_data.get("email") if creator_data else None
-        
+
         organizer_data = google_event.get("organizer", {})
         organizer = organizer_data.get("email") if organizer_data else None
-        
+
         # Parse status
         status = google_event.get("status", "confirmed")
         if status not in VALID_EVENT_STATUSES:
             status = "confirmed"
-        
+
         # Create and return the event
         event = CalendarEvent(
             event_id=event_id,
@@ -137,37 +138,37 @@ def from_google_event(google_event: Dict[str, Any]) -> CalendarEvent:
             organizer=organizer,
             status=status
         )
-        
+
         return event
-        
+
     except Exception:
         raise ValueError("Invalid event data - failed to parse calendar event")
 
 
 def create_event_body(
-    start: datetime,
-    end: datetime,
-    summary: str = None,
-    description: str = None,
-    location: str = None,
-    attendees: List[Attendee] = None,
-    recurrence: List[str] = None
+        start: datetime,
+        end: datetime,
+        summary: str = None,
+        description: str = None,
+        location: str = None,
+        attendees: List[Attendee] = None,
+        recurrence: List[str] = None
 ) -> Dict[str, Any]:
     """
     Create event body dictionary for Google Calendar API.
-    
+
     Args:
         start: Event start datetime
-        end: Event end datetime  
+        end: Event end datetime
         summary: Event summary/title
         description: Event description
         location: Event location
         attendees: List of attendees
         recurrence: List of recurrence rules
-        
+
     Returns:
         Dictionary suitable for Calendar API requests
-        
+
     Raises:
         ValueError: If required fields are invalid
     """
@@ -175,19 +176,19 @@ def create_event_body(
         raise ValueError("Event must have both start and end times")
     if start >= end:
         raise ValueError("Event start time must be before end time")
-    
+
     # Validate text fields
     validate_text_field(summary, MAX_SUMMARY_LENGTH, "summary")
     validate_text_field(description, MAX_DESCRIPTION_LENGTH, "description")
     validate_text_field(location, MAX_LOCATION_LENGTH, "location")
-    
+
     # Build event body
     event_body = {
         'summary': summary or "New Event",
-        'start': {'dateTime': convert_datetime_to_iso(start)},
-        'end': {'dateTime': convert_datetime_to_iso(end)}
+        'start': {'dateTime': convert_datetime_to_iso(start), 'timeZone': tzlocal.get_localzone_name()},
+        'end': {'dateTime': convert_datetime_to_iso(end), 'timeZone': tzlocal.get_localzone_name()}
     }
-    
+
     # Add optional fields
     if description:
         event_body['description'] = sanitize_header_value(description)
@@ -197,50 +198,50 @@ def create_event_body(
         event_body['attendees'] = [attendee.to_dict() for attendee in attendees]
     if recurrence:
         event_body['recurrence'] = recurrence
-        
+
     return event_body
 
 
 def parse_freebusy_response(freebusy_data: Dict[str, Any]) -> FreeBusyResponse:
     """
     Parse a freebusy response from Google Calendar API.
-    
+
     Args:
         freebusy_data: Dictionary containing freebusy response from API
-        
+
     Returns:
         FreeBusyResponse object with parsed data
-        
+
     Raises:
         ValueError: If the response data is invalid
     """
     if not freebusy_data:
         raise ValueError("Empty freebusy response data")
-    
+
     try:
         # Parse time range
         time_min = freebusy_data.get("timeMin")
         time_max = freebusy_data.get("timeMax")
-        
+
         if not time_min or not time_max:
             raise ValueError("Missing timeMin or timeMax in freebusy response")
-        
+
         # Parse start and end times
         start = datetime.fromisoformat(time_min.replace('Z', '+00:00'))
         end = datetime.fromisoformat(time_max.replace('Z', '+00:00'))
-        
+
         # Parse calendar busy periods
         calendars = {}
         calendars_data = freebusy_data.get("calendars", {})
-        
+
         for calendar_id, calendar_data in calendars_data.items():
             busy_periods = []
             busy_data = calendar_data.get("busy", [])
-            
+
             for busy_period in busy_data:
                 period_start_str = busy_period.get("start")
                 period_end_str = busy_period.get("end")
-                
+
                 if period_start_str and period_end_str:
                     try:
                         period_start = datetime.fromisoformat(period_start_str.replace('Z', '+00:00'))
@@ -248,27 +249,27 @@ def parse_freebusy_response(freebusy_data: Dict[str, Any]) -> FreeBusyResponse:
                         busy_periods.append(TimeSlot(start=period_start, end=period_end))
                     except (ValueError, TypeError):
                         continue
-            
+
             calendars[calendar_id] = busy_periods
-        
+
         # Parse errors
         errors = {}
         errors_data = freebusy_data.get("errors", {})
-        
+
         for calendar_id, error_data in errors_data.items():
             if isinstance(error_data, list) and error_data:
                 error_reason = error_data[0].get("reason", "Unknown error")
                 errors[calendar_id] = error_reason
             elif isinstance(error_data, str):
                 errors[calendar_id] = error_data
-        
+
         return FreeBusyResponse(
             start=start,
             end=end,
             calendars=calendars,
             errors=errors
         )
-        
+
     except Exception as e:
         raise ValueError(f"Failed to parse freebusy response: {str(e)}")
 
@@ -276,23 +277,23 @@ def parse_freebusy_response(freebusy_data: Dict[str, Any]) -> FreeBusyResponse:
 def merge_overlapping_time_slots(time_slots: List[TimeSlot]) -> List[TimeSlot]:
     """
     Merge overlapping time slots into consolidated periods.
-    
+
     Args:
         time_slots: List of TimeSlot objects that may overlap
-        
+
     Returns:
         List of merged TimeSlot objects with no overlaps
     """
     if not time_slots:
         return []
-    
+
     # Sort by start time
     sorted_slots = sorted(time_slots, key=lambda x: x.start)
     merged = [sorted_slots[0]]
-    
+
     for current in sorted_slots[1:]:
         last_merged = merged[-1]
-        
+
         # Check if current slot overlaps with the last merged slot
         if current.start <= last_merged.end:
             # Merge by extending the end time if necessary
@@ -301,38 +302,38 @@ def merge_overlapping_time_slots(time_slots: List[TimeSlot]) -> List[TimeSlot]:
         else:
             # No overlap, add as new slot
             merged.append(current)
-    
+
     return merged
 
 
 def validate_freebusy_request(
-    start: datetime,
-    end: datetime,
-    calendar_ids: List[str]
+        start: datetime,
+        end: datetime,
+        calendar_ids: List[str]
 ) -> None:
     """
     Validate parameters for a freebusy request.
-    
+
     Args:
         start: Start datetime for the query
         end: End datetime for the query
         calendar_ids: List of calendar IDs to query
-        
+
     Raises:
         ValueError: If any parameter is invalid
     """
     from .constants import MAX_FREEBUSY_DAYS_RANGE, MAX_CALENDARS_PER_FREEBUSY_QUERY
-    
+
     if start >= end:
         raise ValueError("Start time must be before end time")
-    
+
     # Check maximum time range (Google's API limit)
     days_diff = (end - start).days
     if days_diff > MAX_FREEBUSY_DAYS_RANGE:
         raise ValueError(f"Time range cannot exceed {MAX_FREEBUSY_DAYS_RANGE} days")
-    
+
     if not calendar_ids:
         raise ValueError("At least one calendar ID must be specified")
-    
+
     if len(calendar_ids) > MAX_CALENDARS_PER_FREEBUSY_QUERY:
         raise ValueError(f"Cannot query more than {MAX_CALENDARS_PER_FREEBUSY_QUERY} calendars at once")

{google_api_client_wrapper-1.1.2 → google_api_client_wrapper-1.1.4}/google_client/services/gmail/types.py

@@ -1,4 +1,3 @@
-
 from typing import Optional, List
 from datetime import datetime
 from pydantic import BaseModel, Field
@@ -14,7 +13,6 @@ class EmailAddress(BaseModel):
     email: str = Field(..., description="The email address")
     name: Optional[str] = Field(None, description="The display name")
 
-
     def to_dict(self) -> dict:
         """
         Converts the EmailAddress instance to a dictionary representation.
@@ -42,7 +40,6 @@ class EmailAttachment(BaseModel):
     attachment_id: str = Field(..., description="The unique identifier for the attachment in Gmail")
     message_id: str = Field(..., description="The message id of the message the attachment is attached to")
 
-
     def to_dict(self) -> dict:
         """
         Converts the EmailAttachment instance to a dictionary representation.
@@ -87,7 +84,8 @@ class EmailThread(BaseModel):
     Represents a Gmail thread containing multiple related messages.
     """
     thread_id: Optional[str] = Field(None, description="Unique identifier for the thread")
-    messages: List["EmailMessage"] = Field(default_factory=list, description="List of EmailMessage objects in this thread")
+    messages: List["EmailMessage"] = Field(default_factory=list,
+                                           description="List of EmailMessage objects in this thread")
     snippet: Optional[str] = Field(None, description="A short snippet of the thread content")
     history_id: Optional[str] = Field(None, description="The history ID of the thread")
 
@@ -129,7 +127,7 @@ class EmailThread(BaseModel):
                 participants.add((message.sender.email, message.sender.name))
             for recipient in message.recipients + message.cc_recipients + message.bcc_recipients:
                 participants.add((recipient.email, recipient.name))
-        
+
         return [EmailAddress(email=email, name=name) for email, name in participants]
 
     def __repr__(self):
@@ -159,9 +157,11 @@ class EmailMessage(BaseModel):
     attachments: List[EmailAttachment] = Field(default_factory=list, description="List of attachments in the email")
 
     sender: Optional[EmailAddress] = Field(None, description="The sender's email address information")
-    recipients: List[EmailAddress] = Field(default_factory=list, description="List of recipient email addresses (To field)")
+    recipients: List[EmailAddress] = Field(default_factory=list,
+                                           description="List of recipient email addresses (To field)")
     cc_recipients: List[EmailAddress] = Field(default_factory=list, description="List of CC recipient email addresses")
-    bcc_recipients: List[EmailAddress] = Field(default_factory=list, description="List of BCC recipient email addresses")
+    bcc_recipients: List[EmailAddress] = Field(default_factory=list,
+                                               description="List of BCC recipient email addresses")
 
     date_time: Optional[datetime] = Field(None, description="When the message was sent or received")
 
@@ -238,6 +238,20 @@ class EmailMessage(BaseModel):
         """
         return label in self.labels
 
+    def to_dict(self):
+        return {
+            "message_id": self.message_id,
+            "thread_id": self.thread_id,
+            "sender": self.sender.email,
+            "recipients": [recipient.email for recipient in self.recipients],
+            "date_time": convert_datetime_to_readable(self.date_time),
+            "subject": self.subject,
+            "labels": self.labels,
+            "snippet": self.snippet.encode("ascii", "ignore").decode("ascii"),
+            "body": self.get_plain_text_content().encode("ascii", "ignore").decode("ascii"),
+            "attachments": [attachment.to_dict() for attachment in self.attachments],
+        }
+
     def __repr__(self):
         return (
             f"Subject: {self.subject!r}\n"

{google_api_client_wrapper-1.1.2 → google_api_client_wrapper-1.1.4}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "google-api-client-wrapper"
-version = "1.1.2"
+version = "1.1.4"
 description = "A comprehensive Python wrapper for Google APIs, providing clean and intuitive access to Gmail, Google Drive, Google Calendar, and Google Tasks services."
 readme = {file = "README.md", content-type = "text/markdown"}
 authors = [{name = "Dagmawi Molla", email = "dagmawishewadeg@gmail.com"}]