Obserwowanie wydarzeń dotyczących spotkań za pomocą Pythona i interfejsu Google Meet REST API

W tym samouczku pokazujemy, jak używać interfejsu Google Meet API typu REST wraz z Interfejs Google Workspace Events API i Google Cloud Pub/Sub do obserwowania zdarzeń i reagowania na nie wydarzeniach. Przykładowa aplikacja rejestruje godziny rozpoczęcia i zakończenia konferencji, gdy uczestnicy dołączają do spotkania lub je opuszczają, a także gdy zostaną wygenerowane wszelkie artefakty spotkania. i dostępności informacji.

Więcej informacji o pracy z wydarzeniami znajdziesz w artykule Subskrybowanie Google Meet zdarzenia w interfejsie Google Workspace Events API dokumentacji.

Wymagania wstępne

Jeśli chcesz włączyć któreś z tych wymagań wstępnych w organizacji, zapytaj administrator Google Workspace, aby je włączyć:

• konto Google Workspace z: dostęp do Google Meet.
• Dostęp z możliwością tworzenia projektu Google Cloud.
• Zainstalowano język Python 3.
• zainstalowany interfejs wiersza poleceń gcloud;

Przygotowywanie środowiska

Z tej sekcji dowiesz się, jak utworzyć i skonfigurować środowisko lokalne oraz Projekt Google Cloud na potrzeby tego samouczka.

Utwórz katalog roboczy i środowisko wirtualne Pythona

Aby utworzyć i aktywować nowy obiekt wirtualny , uruchom to w terminalu.

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
source env/bin/activate

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
env/bin/activate.bat

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
env/bin/activate.ps1

Tworzenie projektu Google Cloud

Włącz płatności za projekt Google Cloud

Konfigurowanie uwierzytelniania i autoryzacji

Uwierzytelnianie i autoryzacja umożliwia aplikacji dostęp do interfejsu Meet REST API i zasobami Google Cloud. Wywoływanie interfejsu Meet API REST wymaga autoryzacji użytkownika. Z tej sekcji dowiesz się, jak skonfigurować dane logowania użytkownika i żądania autoryzacji.

Skonfiguruj ekran zgody OAuth i wybierz zakresy

W poniższych krokach sugerowane są informacje o obiektach zastępczych do skonfigurowania ekranu akceptacji OAuth dla do aplikacji. Zanim opublikujesz aplikację na zewnątrz, zaktualizuj te informacje.

1. W konsoli Google Cloud otwórz menu menu. > Interfejsy API i Usługi > Ekran zgody OAuth.

   Otwórz ekran zgody OAuth

2. W sekcji Typ użytkownika wybierz Wewnętrzny i kliknij Utwórz.
3. W polu Nazwa aplikacji wpisz Meet REST API Tutorial.
4. Wypełnij formularz rejestracji aplikacji, a potem kliknij Zapisz i kontynuuj.
5. Kliknij Dodaj lub usuń zakresy. Pojawi się panel z listą zakresów dla każdego interfejsu API włączonego w projekcie Google Cloud.
6. W sekcji Dodaj zakresy ręcznie wklej te zakresy:
   • https://www.googleapis.com/auth/meetings.space.created
7. Kliknij Dodaj do tabeli.
8. Kliknij Aktualizuj.
9. Po wybraniu wymaganych zakresów kliknij Zapisz i kontynuuj.
10. Jeśli jako typ użytkownika wybierzesz Zewnętrzny, dodaj użytkowników testowych:
    1. W sekcji Użytkownicy testowi kliknij Dodaj użytkowników.
    2. Wpisz swój adres e-mail i innych autoryzowanych użytkowników testowych, a następnie kliknij Zapisz i kontynuuj.
11. Przejrzyj podsumowanie rejestracji aplikacji. Aby wprowadzić zmiany, kliknij Edytuj. Jeśli aplikacja z rejestracji wszystko jest w porządku, kliknij Back to Dashboard (Powrót do panelu).

Utwórz identyfikator klienta

Identyfikator klienta działa jako dane logowania dla aplikacji podczas OAuth 2.0 procesu. Aplikacja działa lokalnie, więc utwórz identyfikator klienta na komputer.

1. W konsoli Google Cloud otwórz Menu menu > Interfejsy API i Usługi > Dane logowania.

   Przejdź do danych logowania

2. Kliknij Utwórz dane logowania > Identyfikator klienta OAuth.
3. Kliknij Typ aplikacji > Aplikacja komputerowa.
4. W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest wyświetlana tylko w konsoli Google Cloud.
5. Kliknij Utwórz. Pojawi się ekran tworzenia klienta OAuth z nowym identyfikatorem klienta i tajnym kluczem klienta.
6. Kliknij OK. Nowo utworzone dane logowania pojawią się w sekcji Identyfikatory klienta OAuth 2.0.

Instalowanie bibliotek uwierzytelniania Google

Zainstaluj biblioteki uwierzytelniania Google:

pip install google-auth google-auth-oauthlib

Wykonaj autoryzację

Interfejs Meet REST API wymaga danych logowania użytkownika w formacie OAuth 2.0 token dostępu. W tej sekcji wdrożysz proces OAuth 2.0, aby wysyłać żądania token dostępu i token odświeżania dla użytkownika.

1. W katalogu roboczym utwórz plik main.py i dodaj: zawartość:

   import os
   import json
   
   from google.auth.transport import requests
   from google.oauth2.credentials import Credentials
   from google_auth_oauthlib.flow import InstalledAppFlow
   
   def authorize() -> Credentials:
       """Ensure valid credentials for calling the Meet REST API."""
       CLIENT_SECRET_FILE = "./client_secret.json"
       credentials = None
   
       if os.path.exists('token.json'):
           credentials = Credentials.from_authorized_user_file('token.json')
   
       if credentials is None:
           flow = InstalledAppFlow.from_client_secrets_file(
               CLIENT_SECRET_FILE,
               scopes=[
                   'https://www.googleapis.com/auth/meetings.space.created',
               ])
           flow.run_local_server(port=0)
           credentials = flow.credentials
   
       if credentials and credentials.expired:
           credentials.refresh(requests.Request())
   
       if credentials is not None:
           with open("token.json", "w") as f:
               f.write(credentials.to_json())
   
       return credentials
   
   USER_CREDENTIALS = authorize()
   

2. Aby uruchomić kod, zarówno identyfikator klienta, jak i utworzony wcześniej obiekt tajny są Skopiuj pobrany plik z tajnymi kluczami klienta do działającego projektu i zmień nazwę na client_secret.json.

3. Jeśli chcesz sprawdzić, jak działa autoryzacja, uruchom następujące polecenie. Aplikacja prosi o autoryzację i tworzy plik token.json w katalogu roboczym projektu.

   python3 main.py
   

Dodawanie interfejsu Meet API typu REST

Po wprowadzeniu kodu autoryzacji czas włączyć i wywołać metodę Poznaj interfejs API REST.

Włączanie interfejsów API

Chociaż ta sekcja dotyczy interfejsu Meet REST API, w tym samouczku używamy też Google Cloud Pub/Sub i Google Workspace Events API.

Instalowanie biblioteki klienta interfejsu Meet REST API

Aby zainstalować bibliotekę klienta interfejsu Meet REST API, wykonaj te czynności:

1. Uruchom polecenie:

   pip install google-apps-meet
   

2. Edytuj plik main.py, aby zaimportować klienta:

   from google.apps import meet_v2 as meet
   

Utwórz pokój

Interfejs Meet REST API jest już dostępny. Teraz zdefiniuj funkcję, aby utworzyć miejsce spotkań, które można subskrybować.

Edytuj main.py i dodaj:

def create_space() -> meet.Space:
    """Create a meeting space."""
    client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
    request = meet.CreateSpaceRequest()
    return client.create_space(request=request)

Subskrybuj wydarzenia

Aby otrzymywać informacje o wydarzeniach dotyczących sali konferencyjnej, utwórz subskrypcję za pomocą Interfejs Google Workspace Events API. Musisz też utworzyć i zasubskrybować Temat Google Cloud Pub/Sub, który służy jako punkt końcowy powiadomień, w którym odbiera zdarzenia.

Konfigurowanie Google Cloud Pub/Sub

Aby utworzyć i zasubskrybować temat Pub/Sub:

Zanotuj nazwę tematu i upewnij się, że wartością w polu {project} jest Identyfikator projektu Cloud dla Twojej aplikacji. Nazwa tematu służy do tworzenia Subskrypcja Google Workspace później.

Tworzenie konta usługi

Użyj konta usługi

Po utworzeniu konta usługi przyznaj sobie dostęp umożliwiający przyjęcie tożsamości konta usługi.

Instalowanie biblioteki klienta Pub/Sub

1. Użyj pip, aby zainstalować bibliotekę klienta dla Pub/Sub:

   pip install google-cloud-pubsub
   

2. Następnie zmodyfikuj main.py, aby zaimportować klienta:

   from google.cloud import pubsub_v1
   

Tworzenie subskrypcji Google Workspace

Dodaj do main.py ten kod, aby zdefiniować metodę subskrybowania Wydarzenia w Meet. Ten kod subskrybuje wszystkie wydarzenia dotyczące spotkania kosmosu. Po zasubskrybowaniu wydarzenia są publikowane w temacie Pub/Sub.

def subscribe_to_space(space_name: str = None, topic_name: str = None):
    """Subscribe to events for a meeting space."""
    session = requests.AuthorizedSession(USER_CREDENTIALS)
    body = {
        'targetResource': f"//meet.googleapis.com/{space_name}",
        "eventTypes": [
            "google.workspace.meet.conference.v2.started",
            "google.workspace.meet.conference.v2.ended",
            "google.workspace.meet.participant.v2.joined",
            "google.workspace.meet.participant.v2.left",
            "google.workspace.meet.recording.v2.fileGenerated",
            "google.workspace.meet.transcript.v2.fileGenerated",
        ],
        "payloadOptions": {
            "includeResource": False,
        },
        "notificationEndpoint": {
            "pubsubTopic": topic_name
        },
        "ttl": "86400s",
    }
    response = session.post("https://workspaceevents.googleapis.com/v1/subscriptions", json=body)
    return response

Następnie dodaj odpowiedni kod, aby pobierać i przetwarzać zdarzenia.

Wykrywaj zdarzenia i obsługuj je

Kontynuuj edycję main.py i dodaj ten przykładowy kod. Ten kod implementuje stronę odbierającą i wykorzystuje interfejs Google Cloud Pub/Sub API do pobierania wydarzenia w miarę ich udostępniania. Różne metody obsługi drukowania informacji na temat odpowiednich zdarzeń.

def format_participant(participant: meet.Participant) -> str:
    """Formats a participant for display on the console."""
    if participant.anonymous_user:
        return f"{participant.anonymous_user.display_name} (Anonymous)"

    if participant.signedin_user:
        return f"{participant.signedin_user.display_name} (ID: {participant.signedin_user.user})"

    if participant.phone_user:
        return f"{participant.phone_user.display_name} (Phone)"

    return "Unknown participant"


def fetch_participant_from_session(session_name: str) -> meet.Participant:
    """Fetches the participant for a session."""
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    # Use the parent path of the session to fetch the participant details
    parsed_session_path = client.parse_participant_session_path(session_name)
    participant_resource_name = client.participant_path(
        parsed_session_path["conference_record"],
        parsed_session_path["participant"])
    return client.get_participant(name=participant_resource_name)


def on_conference_started(message: pubsub_v1.subscriber.message.Message):
    """Display information about a conference when started."""
    payload = json.loads(message.data)
    resource_name = payload.get("conferenceRecord").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    conference = client.get_conference_record(name=resource_name)
    print(f"Conference (ID {conference.name}) started at {conference.start_time.rfc3339()}")


def on_conference_ended(message: pubsub_v1.subscriber.message.Message):
    """Display information about a conference when ended."""
    payload = json.loads(message.data)
    resource_name = payload.get("conferenceRecord").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    conference = client.get_conference_record(name=resource_name)
    print(f"Conference (ID {conference.name}) ended at {conference.end_time.rfc3339()}")


def on_participant_joined(message: pubsub_v1.subscriber.message.Message):
    """Display information about a participant when they join a meeting."""
    payload = json.loads(message.data)
    resource_name = payload.get("participantSession").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    session = client.get_participant_session(name=resource_name)
    participant = fetch_participant_from_session(resource_name)
    display_name = format_participant(participant)
    print(f"{display_name} joined at {session.start_time.rfc3339()}")


def on_participant_left(message: pubsub_v1.subscriber.message.Message):
    """Display information about a participant when they leave a meeting."""
    payload = json.loads(message.data)
    resource_name = payload.get("participantSession").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    session = client.get_participant_session(name=resource_name)
    participant = fetch_participant_from_session(resource_name)
    display_name = format_participant(participant)
    print(f"{display_name} left at {session.end_time.rfc3339()}")


def on_recording_ready(message: pubsub_v1.subscriber.message.Message):
    """Display information about a recorded meeting when artifact is ready."""
    payload = json.loads(message.data)
    resource_name = payload.get("recording").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    recording = client.get_recording(name=resource_name)
    print(f"Recording available at {recording.drive_destination.export_uri}")


def on_transcript_ready(message: pubsub_v1.subscriber.message.Message):
    """Display information about a meeting transcript when artifact is ready."""
    payload = json.loads(message.data)
    resource_name = payload.get("transcript").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    transcript = client.get_transcript(name=resource_name)
    print(f"Transcript available at {transcript.docs_destination.export_uri}")


def on_message(message: pubsub_v1.subscriber.message.Message) -> None:
    """Handles an incoming event from the Google Cloud Pub/Sub API."""
    event_type = message.attributes.get("ce-type")
    handler = {
        "google.workspace.meet.conference.v2.started": on_conference_started,
        "google.workspace.meet.conference.v2.ended": on_conference_ended,
        "google.workspace.meet.participant.v2.joined": on_participant_joined,
        "google.workspace.meet.participant.v2.left": on_participant_left,
        "google.workspace.meet.recording.v2.fileGenerated": on_recording_ready,
        "google.workspace.meet.transcript.v2.fileGenerated": on_transcript_ready,
    }.get(event_type)

    try:
        if handler is not None:
            handler(message)
        message.ack()
    except Exception as error:
        print("Unable to process event")
        print(error)


def listen_for_events(subscription_name: str = None):
    """Subscribe to events on the subscription."""
    subscriber = pubsub_v1.SubscriberClient()
    with subscriber:
        future = subscriber.subscribe(subscription_name, callback=on_message)
        print("Listening for events")
        try:
            future.result()
        except KeyboardInterrupt:
            future.cancel()
    print("Done")

Dokończ kod

Dodaj do main.py ten kod, aby wywoływać metody tworzenia pokoju: subskrybować wydarzenia i nasłuchiwać. Zaktualizuj aplikację TOPIC_NAME i stałe SUBSCRIPTION_NAME z własnym tematem i nazwy subskrypcji, które wcześniej Utworzono.

1. Dodaj kod do main.py:

   space = create_space()
   print(f"Join the meeting at {space.meeting_uri}")
   
   TOPIC_NAME = "projects/PROJECT_ID/topics/TOPIC_ID"
   SUBSCRIPTION_NAME = "projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID"
   
   subscription = subscribe_to_space(topic_name=TOPIC_NAME, space_name=space.name)
   listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   

   Zastąp następujące elementy:

   • PROJECT_ID: unikalny identyfikator projektu Cloud dla: aplikacji, np. my-sample-project-191923.

   • TOPIC_ID: nazwa tematu Pub/Sub, utworzonych w projekcie Cloud.

   • SUBSCRIPTION_ID: nazwa subskrypcji, np. jako workspace-events-sub.

2. Uruchom program:

   python3 main.py
   

Jeśli program nie został wcześniej uruchomiony, wyświetli się prośba o autoryzację za pierwszym razem. Przyznaj aplikacji dostęp, aby móc wywoływać interfejs Meet REST API. Po uruchomieniu programu powinny wyświetlić się wyniki podobne do tych:

Join the meeting at https://meet.google.com/abc-mnop-xyz

Dołącz do konferencji

Aby wygenerować zdarzenia dla aplikacji, dołącz do konferencji za pomocą adresu URL wyświetlanych przez aplikację. Po dołączeniu możesz wykonać te działania, aby: zdarzenia aktywujące:

• Opuść spotkanie i dołącz do niego ponownie.
• Zaproś innych lub dołącz przez telefon.
• Włącz nagrywanie i transkrypcję.

Każde z tych działań generuje zdarzenie, które aplikacja odbiera w konsoli Google Cloud.

Użyj ctrl-c, aby przerwać program, gdy skończysz.

Opcjonalnie: dodatkowe kroki do wypróbowania

Aplikacja rejestruje podstawowe informacje o zdarzeniach. Aby dalej poznawać Poznaj interfejs API REST. Zmodyfikuj aplikację, aby wykonać te dodatkowe .

• Za pomocą interfejsu People API możesz uzyskać dodatkowe informacje o: zalogowanych uczestników.
• Używanie interfejsu Google Drive API do pobierania nagrań i transkrypcje.
• Zamiast pobierać transkrypcje z Dysku Google, pobieraj je za pomocą transkrypcja uporządkowanych danych w interfejsie Meet REST API.

Opcjonalnie: wyczyść

Aby uniknąć obciążenia konta konsoli Google Cloud opłatami za zasoby użyte w tym samouczku, zalecamy wyczyszczenie wszystkich zasobów i projektów Utworzono.

Aby usunąć subskrypcję:

Aby usunąć temat:

Aby usunąć projekt:

Powiązane artykuły

• Dowiedz się więcej o możliwościach interfejsu Google Meet REST API oraz zapoznaj się z dokumentacją referencyjną.
• Dowiedz się, jak subskrybować wydarzenia za pomocą zdarzeń Google Workspace API.
• Więcej informacji o uwierzytelnianiu znajdziesz w artykule Konfigurowanie ekranu zgody OAuth i wybierz zakresy.