Observer des événements de réunion à l'aide de Python et de l'API REST Google Meet

Ce tutoriel explique comment utiliser l'API REST Google Meet avec la l'API Google Workspace Events et Google Cloud Pub/Sub pour observer les événements et y réagir ; dans un espace de réunion Meet. L'exemple d'application enregistre quand début et de fin d'une conférence, à quel moment des participants rejoignent ou quittent et les artefacts de réunion générés sont disponibles.

Au lieu de vous abonner à un espace de réunion spécifique, vous pouvez vous abonner à un utilisateur Meet de recevoir les événements de n'importe quel espace de réunion auquel que l’utilisateur possède ou organise. Pour en savoir plus, consultez S'abonner aux événements Google Meet dans la documentation de l'API Google Workspace Events.

Prérequis

Si vous avez besoin d'activer l'un de ces prérequis pour votre organisation, contactez votre administrateur Google Workspace pour les activer:

• Un compte Google Workspace avec l'accès à Google Meet.
• Accès pour créer un projet Google Cloud
• Python 3 installé.
• gcloud CLI installée.

Préparer votre environnement

Cette section explique comment créer et configurer votre environnement local et le projet Google Cloud pour ce tutoriel.

Créer un répertoire de travail et un environnement virtuel Python

Pour créer et activer un nouveau , exécutez la commande suivante : dans votre terminal.

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

Créer un projet Google Cloud

Activer la facturation pour le projet Google Cloud

Configurer l'authentification et l'autorisation

L'authentification et l'autorisation permettent à l'application d'accéder à l'API REST Meet ressources. L'autorisation de l'utilisateur est requise pour appeler l'API REST Meet. Cette section explique comment configurer les identifiants utilisateur et les requêtes une autorisation.

Configurer l'écran de consentement OAuth et choisir les niveaux d'accès

Les étapes suivantes suggèrent des informations d'espace réservé pour configurer l'écran de consentement OAuth de votre application. Avant de publier l'application en externe, mettez à jour ces informations.

1. Dans la console Google Cloud, accédez à Menu menu > API et services > Écran de consentement OAuth.

   Accéder à l'écran de consentement OAuth

2. Sous Type d'utilisateur, sélectionnez Interne, puis cliquez sur Créer.
3. Dans le champ Nom de l'application, saisissez Meet REST API Tutorial.
4. Remplissez le formulaire d'inscription de l'application, puis cliquez sur Enregistrer et continuer.
5. Cliquez sur Ajouter ou supprimer des habilitations. Un panneau s'affiche avec une liste des champs d'application pour chaque API que vous avez activée dans votre projet Google Cloud.
6. Sous Ajouter manuellement des champs d'application, collez les champs d'application suivants: <ph type="x-smartling-placeholder">
   </ph>
   • https://www.googleapis.com/auth/meetings.space.created
7. Cliquez sur Ajouter à la table.
8. Cliquez sur Mettre à jour.
9. Après avoir sélectionné les niveaux d'accès requis de votre application, cliquez sur Enregistrer et continuer.
10. Si vous avez sélectionné le type d'utilisateur Externe, ajoutez des utilisateurs tests: <ph type="x-smartling-placeholder">
    </ph>
    1. Sous Utilisateurs de test, cliquez sur Ajouter des utilisateurs.
    2. Saisissez votre adresse e-mail et le nom de tout autre utilisateur test autorisé, puis cliquez sur Enregistrer et continuer.
11. Consultez le récapitulatif d'enregistrement de votre application. Pour y apporter des modifications, cliquez sur Modifier. Si l'enregistrement de l'application semble correct, cliquez sur Revenir au tableau de bord.

Créer un ID client

L'ID client sert d'identifiants pour votre application lors des flux OAuth 2.0. Étant donné que l'application s'exécute localement, créez un ID client de bureau.

1. Dans la console Google Cloud, accédez à Menu menu &gt; API et Services &gt; Identifiants.

   Accéder à "Identifiants"

2. Cliquez sur Créer des identifiants &gt; ID client OAuth.
3. Cliquez sur Type d'application &gt; Application de bureau.
4. Dans le champ Nom, saisissez un nom pour l'identifiant. Ce nom ne s'affiche que dans la console Google Cloud.
5. Cliquez sur Créer. L'écran "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.
6. Cliquez sur OK. Les nouveaux identifiants s'affichent sous ID clients OAuth 2.0.

Installer les bibliothèques d'authentification Google

Installez les bibliothèques d'authentification Google:

pip install google-auth google-auth-oauthlib

Exécuter l'autorisation

L'API REST Meet nécessite des identifiants utilisateur sous la forme d'un protocole OAuth 2.0 un jeton d'accès. Dans cette section, vous allez implémenter le flux OAuth 2.0 pour demander un un jeton d'accès et un jeton d'actualisation pour l'utilisateur.

1. Dans votre répertoire de travail, créez le fichier main.py et ajoutez ce qui suit : contenus:

   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. Pour exécuter le code, l'ID client et le secret créé précédemment sont obligatoire. Copiez le fichier secret du client téléchargé dans le projet actif. et renommez-le client_secret.json.

3. Si vous souhaitez tester le fonctionnement de l'autorisation, exécutez la commande suivante. L'application demande une autorisation et crée un fichier token.json dans le fichier dans le répertoire de travail du projet une fois la demande approuvée.

   python3 main.py

Ajouter l'API REST Meet

Maintenant que le code d'autorisation est terminé, vous pouvez activer et appeler la méthode Découvrez l'API REST.

Activer les API

Bien que cette section soit consacrée à l'API REST Meet, ce tutoriel utilise également Google Cloud Pub/Sub et l'API Google Workspace Events.

Installer la bibliothèque cliente de l'API REST Meet

Pour installer la bibliothèque cliente de l'API REST Meet, procédez comme suit:

1. Exécutez la commande suivante :

   pip install google-apps-meet

2. Modifiez le fichier main.py pour importer le client:

   from google.apps import meet_v2 as meet
   

Créer un espace

Maintenant que l'API REST Meet est disponible, définissez une fonction pour créer un un espace de réunion auquel s'abonner.

Modifiez main.py et ajoutez:

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

S'abonner à des événements

Pour recevoir des événements concernant un espace de réunion, vous devez créer un abonnement à l'aide de l' API Google Workspace Events. Vous devez également créer et vous abonner à un sujet Google Cloud Pub/Sub qui sert de point de terminaison de notification où votre application reçoit les événements.

Configurer Google Cloud Pub/Sub

Pour créer un sujet Pub/Sub et vous y abonner :

Notez le nom du sujet et assurez-vous que la valeur de {project} est bien ID de projet Google Cloud de votre application. Vous utiliserez le nom du sujet pour créer abonnement Google Workspace plus tard.

Créer un compte de service

Utiliser le compte de service

Après avoir créé le compte de service, accordez-vous l'accès pour emprunter l'identité du de service géré.

Installer la bibliothèque cliente Pub/Sub

1. Installez la bibliothèque cliente pour Pub/Sub à l'aide de pip:

   pip install google-cloud-pubsub

2. Ensuite, modifiez main.py pour importer le client:

   from google.cloud import pubsub_v1
   

Créer l'abonnement Google Workspace

Ajoutez le code suivant à main.py pour définir une méthode d'abonnement à Événements Meet. Ce code s'abonne à tous les événements d'une réunion espace. Une fois abonné, les événements sont publiés dans le sujet 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

Ajoutez ensuite le code correspondant pour extraire et traiter les événements.

Écouter et gérer les événements

Poursuivez la modification de main.py et ajoutez l'exemple de code suivant. Ce code met en œuvre le côté réception et utilise l'API Google Cloud Pub/Sub pour extraire les événements dès qu'ils sont disponibles. Les différentes méthodes de gestionnaire impriment des informations. sur les événements correspondants.

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")

Finaliser le code

Ajoutez le code suivant à main.py pour appeler les méthodes permettant de créer l'espace : s'abonner à des événements et les écouter. Mettre à jour TOPIC_NAME et les constantes SUBSCRIPTION_NAME par votre propre sujet et d'abonnement que vous avez précédemment créé.

1. Ajoutez le code à 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)
   

   Remplacez les éléments suivants :

   • PROJECT_ID : ID de projet Cloud unique de votre application, par exemple my-sample-project-191923.

   • TOPIC_ID: nom du sujet Pub/Sub que vous créés dans votre projet Cloud.

   • SUBSCRIPTION_ID : nom de votre abonnement, par exemple workspace-events-sub.

2. Exécutez le programme:

   python3 main.py

Si vous n'avez pas encore exécuté le programme, vous êtes invité à autoriser le pour la première fois. Accordez l'accès à l'application pour appeler l'API REST Meet. Une fois le programme exécuté, un résultat semblable aux lignes suivantes doit s'afficher:

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

Participer à la conférence

Pour générer des événements pour l'application, rejoignez la conférence à l'aide de l'URL affichées par l'application. Une fois que vous aurez rejoint la communauté, vous pourrez essayer ces actions pour : les événements déclencheurs:

• Quittez la réunion, puis rejoignez-la.
• Invitez d'autres personnes ou composez le numéro de téléphone.
• Activez les enregistrements et les transcriptions.

Chacune de ces activités génère un événement reçu par l'application les journaux à la console Google Cloud.

Utilisez ctrl-c pour interrompre le programme lorsque vous avez terminé.

Facultatif: étapes supplémentaires à essayer

L'application consigne les informations de base sur les événements. Pour continuer à explorer de l'API REST Meet, essayez de modifier l'application pour effectuer ces opérations actions.

• Utilisez l'API People pour récupérer des informations supplémentaires sur participants connectés.
• Utilisez l'API Google Drive pour télécharger des enregistrements et des transcriptions.
• Au lieu de télécharger les transcriptions depuis Google Drive, récupérez-les via la transcription structurée méthodes dans l'API REST Meet.

Facultatif : Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel ne soient facturées sur votre compte Google Cloud, nous vous recommandons de nettoyer toutes les ressources et tous les projets créés.

Pour supprimer l'abonnement:

Pour supprimer le sujet:

Pour supprimer le projet :

Articles associés

• En savoir plus sur les les types d'événements Meet auxquels vous pouvez vous abonner.
• En savoir plus sur les fonctionnalités de l'API REST Google Meet et consultez la documentation de référence.
• Créer un abonnement Google Workspace aux espaces de réunion Meet ou aux utilisateurs API Google Workspace Events.
• Pour en savoir plus sur l'authentification, consultez Configurer l'écran de consentement OAuth et choisir des niveaux d'accès.