Fixed issues with the current notetaker implementation

Author: AaronDDM

examples/notetaker_api_demo/notetaker_demo.py

@@ -2,7 +2,7 @@
 import sys
 import json
 from nylas import Client
-from nylas.models.notetakers import NotetakerMeetingSettings, NotetakerState, InviteNotetakerRequest
+from nylas.models.notetakers import NotetakerMeetingSettingsRequest, NotetakerState, InviteNotetakerRequest
 from nylas.models.errors import NylasApiError
 
 # Initialize the Nylas client
@@ -92,18 +92,18 @@ def get_notetaker_media(notetaker_id):
         print(f"Unexpected error in get_notetaker_media: {str(e)}")
         raise
 
-def cancel_notetaker(notetaker_id):
-    """Demonstrates how to cancel a Notetaker."""
-    print("\n=== Canceling Notetaker ===")
+def leave_notetaker(notetaker_id):
+    """Demonstrates how to leave a Notetaker."""
+    print("\n=== Leaving Notetaker ===")
 
     try:
-        nylas.notetakers.cancel(notetaker_id)
-        print(f"Cancelled Notetaker with ID: {notetaker_id}")
+        nylas.notetakers.leave(notetaker_id)
+        print(f"Left Notetaker with ID: {notetaker_id}")
     except NylasApiError as e:
-        print(f"Error canceling notetaker: {str(e)}")
+        print(f"Error leaving notetaker: {str(e)}")
         raise
     except Exception as e:
-        print(f"Unexpected error in cancel_notetaker: {str(e)}")
+        print(f"Unexpected error in leave_notetaker: {str(e)}")
         raise
 
 def main():
@@ -125,8 +125,8 @@ def main():
         if notetaker.data.state == NotetakerState.MEDIA_AVAILABLE:
             get_notetaker_media(notetaker.data.id)
 
-        # Cancel the Notetaker
-        cancel_notetaker(notetaker.data.id)
+        # Leave the Notetaker
+        leave_notetaker(notetaker.data.id)
 
     except NylasApiError as e:
         print(f"\nNylas API Error: {str(e)}")

examples/notetaker_calendar_demo/notetaker_calendar_demo.py

@@ -1,9 +1,20 @@
 import os
 from datetime import datetime, timedelta
+from typing import Optional
 
 from nylas import Client
-from nylas.models.notetakers import NotetakerMeetingSettings, MeetingProvider
-from nylas.models.events import EventMetadata
+from nylas.models.notetakers import Notetaker
+from nylas.models.events import (
+    UpdateEventRequest,
+    CreateEventRequest,
+    EventNotetakerRequest,
+    EventNotetakerSettings,
+    CreateTimespan,
+    CreateEventQueryParams,
+    UpdateEventQueryParams,
+    CreateAutocreate,
+    CreateEventNotetaker
+)
 
 # Initialize the Nylas client
 nylas = Client(
@@ -18,92 +29,147 @@ def create_event_with_notetaker():
     # Create the event
     start_time = datetime.now() + timedelta(days=1)
     end_time = start_time + timedelta(hours=1)
-    
-    event = nylas.events.create(
+
+
+    # Create the request body with proper types
+    request_body = CreateEventRequest(
         title="Project Planning Meeting",
         description="Initial project planning and resource allocation",
-        start_time=start_time,
-        end_time=end_time,
-        metadata=EventMetadata(
-            project_id="PROJ-123",
-            priority="high"
+        when=CreateTimespan(
+            start_time=int(start_time.timestamp()),
+            end_time=int(end_time.timestamp())
+        ),
+        metadata={
+            "project_id": "PROJ-123",
+            "priority": "high"
+        },
+        conferencing=CreateAutocreate(
+            provider="Google Meet",
+            autocreate={}
+        ),
+        notetaker=CreateEventNotetaker(
+            name="Nylas Notetaker",
+            meeting_settings=EventNotetakerSettings(
+                video_recording=True,
+                audio_recording=True,
+                transcription=True
+            )
         )
     )
 
-    # Create a Notetaker bot for the event
-    notetaker = nylas.notetakers.invite(
-        meeting_link=event.conferencing.details.meeting_url,
-        name="Project Planning Notetaker",
-        meeting_settings=NotetakerMeetingSettings(
-            video_recording=True,
-            audio_recording=True,
-            transcription=True
-        )
+    # Create the query parameters
+    query_params = CreateEventQueryParams(
+        calendar_id=os.getenv("NYLAS_CALENDAR_ID")
     )
 
-    print(f"Created event with ID: {event.id}")
-    print(f"Created Notetaker with ID: {notetaker.id}")
-    return event, notetaker
+    event = nylas.events.create(
+        identifier=os.getenv("NYLAS_GRANT_ID"),
+        request_body=request_body,
+        query_params=query_params
+    )
+
+    return event
 
-def get_event_notetaker(event_id):
+
+def get_event_notetaker(event_id: str) -> Optional[Notetaker]:
     """Demonstrates how to retrieve the Notetaker associated with an event."""
     print("\n=== Retrieving Event Notetaker ===")
 
     # First get the event to get the Notetaker ID
-    event = nylas.events.find(event_id)
-    if not event.notetaker or not event.notetaker.id:
+    try:
+        event = nylas.events.find(
+            identifier=os.getenv("NYLAS_GRANT_ID"),
+            event_id=event_id,
+            query_params={"calendar_id": os.getenv("NYLAS_CALENDAR_ID")}
+        )
+    except Exception as e:
+        print(f"Error getting event: {e}")
+        return None
+    
+    if not event.data.notetaker or not event.data.notetaker.id:
         print(f"No Notetaker found for event {event_id}")
         return None
 
-    notetaker = nylas.notetakers.find(event.notetaker.id)
+    notetaker = nylas.notetakers.find(notetaker_id=event.data.notetaker.id, identifier=os.getenv("NYLAS_GRANT_ID"))
     print(f"Found Notetaker for event {event_id}:")
-    print(f"- ID: {notetaker.id}")
-    print(f"- State: {notetaker.state}")
-    print(f"- Meeting Provider: {notetaker.meeting_provider}")
+    print(f"- ID: {notetaker.data.id}")
+    print(f"- State: {notetaker.data.state}")
+    print(f"- Meeting Provider: {notetaker.data.meeting_provider}")
+    print(f"- Meeting Settings:")
+    print(f"  - Video Recording: {notetaker.data.meeting_settings.video_recording}")
+    print(f"  - Audio Recording: {notetaker.data.meeting_settings.audio_recording}")
+    print(f"  - Transcription: {notetaker.data.meeting_settings.transcription}")
 
     return notetaker
 
-def update_event_and_notetaker(event_id, notetaker_id):
+def update_event_and_notetaker(event_id: str, notetaker_id: str):
     """Demonstrates how to update both an event and its Notetaker."""
     print("\n=== Updating Event and Notetaker ===")
 
-    # Update the event
-    updated_event = nylas.events.update(
-        event_id,
+    # Create the notetaker meeting settings
+    notetaker_settings = EventNotetakerSettings(
+        video_recording=False,
+        audio_recording=True,
+        transcription=False
+    )
+    
+    # Create the notetaker request
+    notetaker = EventNotetakerRequest(
+        id=notetaker_id,
+        name="Updated Nylas Notetaker",
+        meeting_settings=notetaker_settings
+    )
+    
+    # Create the update request with proper types
+    request_body = UpdateEventRequest(
         title="Updated Project Planning Meeting",
         description="Revised project planning with new timeline",
-        metadata=EventMetadata(
-            project_id="PROJ-123",
-            priority="urgent"
-        )
+        metadata={
+            "project_id": "PROJ-123",
+            "priority": "urgent"
+        },
+        notetaker=notetaker
     )
 
-    # Update the Notetaker
-    updated_notetaker = nylas.notetakers.update(
-        notetaker_id,
-        name="Updated Project Planning Notetaker",
-        meeting_settings=NotetakerMeetingSettings(
-            video_recording=True,
-            audio_recording=True,
-            transcription=True
-        )
+    # Create the query parameters
+    query_params = UpdateEventQueryParams(
+        calendar_id=os.getenv("NYLAS_CALENDAR_ID")
+    )
+
+    updated_event = nylas.events.update(
+        identifier=os.getenv("NYLAS_GRANT_ID"),
+        event_id=event_id,
+        request_body=request_body,
+        query_params=query_params
     )
 
-    print(f"Updated event with ID: {updated_event.id}")
-    print(f"Updated Notetaker with ID: {updated_notetaker.id}")
-    return updated_event, updated_notetaker
+    return updated_event
 
 def main():
     """Main function to run all demo examples."""
     try:
         # Create an event with a Notetaker
-        event, notetaker = create_event_with_notetaker()
+        event = create_event_with_notetaker()
+        if not event:
+            print("Failed to create event")
+            return
+        
+        print(f"Created event with ID: {event.data.id}")
+        print(f"Event Notetaker ID: {event.data.notetaker.id}")
 
         # Get the Notetaker for the event
-        get_event_notetaker(event.id)
+        notetaker = get_event_notetaker(event.data.id)
+        if not notetaker:
+            print(f"Failed to get Notetaker for event {event.data.id}")
+            return
 
         # Update both the event and its Notetaker
-        updated_event, updated_notetaker = update_event_and_notetaker(event.id, notetaker.id)
+        updated_event = update_event_and_notetaker(event.data.id, notetaker.data.id)
+        if not updated_event:
+            print(f"Failed to update event {event.data.id}")
+            return
+        
+        print(f"Updated event with ID: {updated_event.data.id}")
 
     except Exception as e:
         print(f"An error occurred: {str(e)}")

nylas/models/events.py

@@ -706,6 +706,18 @@ class EventNotetakerRequest(TypedDict):
     meeting_settings: NotRequired[EventNotetakerSettings]
 
 
+class CreateEventNotetaker(TypedDict):
+    """
+    Class representing Notetaker settings for an event.
+
+    Attributes:
+        name: The display name for the Notetaker bot.
+        meeting_settings: Notetaker Meeting Settings.
+    """
+
+    name: Optional[str] = "Nylas Notetaker"
+    meeting_settings: Optional[EventNotetakerSettings] = None
+
 class CreateEventRequest(TypedDict):
     """
     Interface representing a request to create an event.
@@ -741,7 +753,7 @@ class CreateEventRequest(TypedDict):
     visibility: NotRequired[Visibility]
     capacity: NotRequired[int]
     hide_participants: NotRequired[bool]
-    notetaker: NotRequired[EventNotetakerRequest]
+    notetaker: NotRequired[CreateEventNotetaker]
 
 
 class UpdateEventRequest(TypedDict):

nylas/models/notetakers.py

@@ -50,6 +50,22 @@ class MeetingProvider(str, Enum):
     MICROSOFT_TEAMS = "Microsoft Teams"
 
 
+class NotetakerMeetingSettingsRequest(TypedDict):
+    """
+    Interface representing Notetaker meeting settings for request objects.
+
+    Attributes:
+        video_recording: When true, Notetaker records the meeting's video.
+        audio_recording: When true, Notetaker records the meeting's audio.
+        transcription: When true, Notetaker transcribes the meeting's audio. 
+            If transcription is true, audio_recording must also be true.
+    """
+
+    video_recording: Optional[bool]
+    audio_recording: Optional[bool]
+    transcription: Optional[bool]
+
+
 @dataclass_json
 @dataclass
 class NotetakerMeetingSettings:
@@ -63,9 +79,9 @@ class NotetakerMeetingSettings:
             If transcription is true, audio_recording must also be true.
     """
 
-    video_recording: Optional[bool] = True
-    audio_recording: Optional[bool] = True
-    transcription: Optional[bool] = True
+    video_recording: bool = True
+    audio_recording: bool = True
+    transcription: bool = True
 
 
 @dataclass_json
@@ -152,7 +168,7 @@ def has_media_available(self) -> bool:
 
 class InviteNotetakerRequest(TypedDict):
     """
-    Class representation of the Nylas notetaker creation request.
+    Interface representing the Nylas notetaker creation request.
 
     Attributes:
         meeting_link: A meeting invitation link that Notetaker uses to join the meeting.
@@ -165,12 +181,12 @@ class InviteNotetakerRequest(TypedDict):
     meeting_link: str
     join_time: NotRequired[int]
     name: NotRequired[str]
-    meeting_settings: NotRequired[dict]
+    meeting_settings: NotRequired[NotetakerMeetingSettingsRequest]
 
 
 class UpdateNotetakerRequest(TypedDict):
     """
-    Class representation of the Nylas notetaker update request.
+    Interface representing the Nylas notetaker update request.
 
     Attributes:
         join_time: When Notetaker should join the meeting, in Unix timestamp format.
@@ -180,7 +196,7 @@ class UpdateNotetakerRequest(TypedDict):
 
     join_time: NotRequired[int]
     name: NotRequired[str]
-    meeting_settings: NotRequired[dict]
+    meeting_settings: NotRequired[NotetakerMeetingSettingsRequest]
 
 
 class ListNotetakerQueryParams(ListQueryParams):
@@ -220,3 +236,19 @@ class FindNotetakerQueryParams(TypedDict):
     """
 
     select: NotRequired[str]
+
+
+@dataclass_json
+@dataclass
+class NotetakerLeaveResponse:
+    """
+    Class representing a Notetaker leave response.
+
+    Attributes:
+        id: The Notetaker ID.
+        message: A message describing the API response.
+    """
+
+    id: str
+    message: str
+    object: str = "notetaker_leave_response"