Observa reuniones con Python y la API de REST de Google Meet

En este instructivo, se muestra cómo usar la API de REST de Google Meet junto con la API de Google Workspace Events y Google Cloud Pub/Sub para observar eventos y reaccionar a ellos en un espacio de reuniones de Meet. La aplicación de ejemplo registra cuándo comienzan y finalizan las conferencias, cuándo se unen o se van los participantes, y cuándo están disponibles los artefactos de reuniones generados.

En lugar de suscribirte a un espacio de reunión específico, puedes suscribirte a un usuario de Meet para recibir eventos de cualquier espacio de reunión que posea u organice el usuario. Para obtener más detalles, consulta Cómo suscribirse a los eventos de Google Meet en la documentación de la API de Google Workspace Events.

Requisitos previos

Si necesitas que se activen algunos de estos requisitos previos para tu organización, pídele a tu administrador de Google Workspace que los active:

• Una cuenta de Google Workspace con acceso a Google Meet
• Acceso para crear un proyecto de Google Cloud
• Python 3 instalado
• La CLI de gcloud instalada

Prepara el entorno

En esta sección, se muestra cómo crear y configurar tu entorno local y el proyecto de Google Cloud para este instructivo.

Crea un directorio de trabajo y un entorno virtual de Python

Para crear y activar un nuevo entorno virtual, ejecuta los siguientes comandos en tu 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

Crea un proyecto de Google Cloud

Habilita la facturación para el proyecto de Google Cloud

Configura la autenticación y la autorización

La autenticación y la autorización permiten que la app acceda a los recursos de la API de REST de Meet. Se requiere la autorización del usuario para llamar a la API de REST de Meet. En esta sección, se muestra cómo configurar las credenciales del usuario y solicitar la autorización.

Configura la pantalla de consentimiento de OAuth y elige permisos

En los siguientes pasos, se sugiere información de marcador de posición para configurar la pantalla de consentimiento de OAuth de tu app. Antes de publicarla de forma externa, actualiza esta información.

1. En la consola de Google Cloud, ve a Menú menu > Google Auth platform > Branding.

   Ir a Desarrollo de la marca

2. Si ya configuraste Google Auth platform, puedes configurar los siguientes parámetros de configuración de la pantalla de consentimiento de OAuth en Branding, Audience y Data Access. Si ves un mensaje que dice Google Auth platform aún no se configuró, haz clic en Comenzar:
1. En Información de la app, en Nombre de la app, ingresa Meet REST API Tutorial.
2. En Correo electrónico de asistencia del usuario, elige una dirección de correo electrónico de asistencia a la que los usuarios puedan comunicarse contigo si tienen preguntas sobre su consentimiento.
3. Haz clic en Siguiente.
4. En Público, selecciona Interno.
5. Haz clic en Siguiente.
6. En Información de contacto, ingresa una dirección de correo electrónico en la que puedas recibir notificaciones sobre cualquier cambio en tu proyecto.
7. Haz clic en Siguiente.
8. En Finalizar, revisa la Política de Datos del Usuario de los Servicios de las APIs de Google y, si la aceptas, selecciona Acepto la Política de Datos del Usuario de los Servicios de las APIs de Google.
9. Haz clic en Continuar.
10. Haz clic en Crear.
11. Si seleccionaste Externo como el tipo de usuario, agrega usuarios de prueba:
    1. Haz clic en Público.
    2. En Usuarios de prueba, haz clic en Agregar usuarios.
    3. Ingresa tu dirección de correo electrónico y los demás usuarios de prueba autorizados, y haz clic en Guardar.
3. Haz clic en Acceso a los datos > Agregar o quitar permisos. Aparecerá un panel con una lista de los permisos para cada API que habilitaste en tu proyecto de Google Cloud.
4. En Manually add scopes, pega los siguientes permisos:
   • https://www.googleapis.com/auth/meetings.space.created
5. Haz clic en Agregar a la tabla.
6. Haz clic en Actualizar.
7. Después de seleccionar los permisos que requiere tu app, haz clic en Guardar.

Para obtener más información sobre cómo configurar el consentimiento de OAuth, consulta Primeros pasos con Google Auth platform.

Crea un ID de cliente

El ID de cliente actúa como credencial para tu aplicación durante los flujos de OAuth 2.0. Como la app se ejecuta de forma local, crea un ID de cliente de escritorio.

1. En la consola de Google Cloud, ve a Menú menu > Google Auth platform > Clientes.

   Ir a Clientes

2. Haz clic en Crear cliente.
3. Haz clic en Tipo de aplicación > App para computadoras.
4. En el campo Nombre, escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
5. Haz clic en Crear.

   La credencial recién creada aparecerá en "IDs de cliente de OAuth 2.0".

Instala las bibliotecas de Google Auth

Instala las bibliotecas de Google Auth:

pip install google-auth google-auth-oauthlib

Ejecutar autorización

La API de REST de Meet requiere credenciales de usuario en forma de un token de acceso de OAuth 2.0. En esta sección, implementarás el flujo de OAuth 2.0 para solicitar un token de acceso y un token de actualización para el usuario.

1. En tu directorio de trabajo, crea el archivo main.py y agrega el siguiente contenido:

   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. Para ejecutar el código, se requieren el ID de cliente y el secreto que se crearon anteriormente. Copia el archivo del secreto del cliente descargado en el directorio de trabajo del proyecto y cámbiale el nombre a client_secret.json.

3. Si deseas probar cómo funciona la autorización, ejecuta el siguiente comando. La app solicita autorización y crea un archivo token.json en el directorio de trabajo del proyecto después de que se aprueba la solicitud.

   python3 main.py

Agrega la API de REST de Meet

Ahora que el código de autorización está completo, es momento de habilitar y llamar a la API de REST de Meet.

Habilita las APIs

Si bien esta sección se enfoca en la API de REST de Meet, este instructivo también usa la API de Google Cloud Pub/Sub y la API de Google Workspace Events.

Instala la biblioteca cliente de la API de REST de Meet

Sigue estos pasos para instalar la biblioteca cliente de la API de REST de Meet:

1. Ejecuta el siguiente comando:

   pip install google-apps-meet

2. Edita el archivo main.py para importar el cliente:

   from google.apps import meet_v2 as meet
   

Crea un espacio

Ahora que la API de REST de Meet está disponible, define una función para crear un espacio de reunión al que se pueda suscribir.

Edita main.py y agrega lo siguiente:

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

Suscríbete a eventos

Para recibir eventos sobre un espacio de reunión, crea una suscripción con la API de Google Workspace Events. También debes crear un tema de Google Cloud Pub/Sub y suscribirte a él, que funcionará como el extremo de notificación en el que tu app recibirá los eventos.

Configura Google Cloud Pub/Sub

Para crear un tema de Pub/Sub y suscribirte a él, haz lo siguiente:

Anota el nombre del tema y asegúrate de que el valor de {project} sea el ID del proyecto de Cloud de tu app. Usarás el nombre del tema para crear la suscripción a Google Workspace más adelante.

Crea una cuenta de servicio

Usa la cuenta de servicio

Después de crear la cuenta de servicio, otórgate acceso para suplantar la identidad de la cuenta de servicio.

Instala la biblioteca cliente de Pub/Sub

1. Usa pip para instalar la biblioteca cliente de Pub/Sub:

   pip install google-cloud-pubsub

2. Luego, edita main.py para importar el cliente:

   from google.cloud import pubsub_v1
   

Crea la suscripción a Google Workspace

Agrega el siguiente código a main.py para definir un método para suscribirse a eventos de Meet. Este código se suscribe a todos los eventos de una sala de reuniones. Cuando te suscribes, los eventos se publican en el tema de 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

A continuación, agrega el código correspondiente para extraer y procesar los eventos.

Cómo detectar y controlar eventos

Sigue editando main.py y agrega el siguiente código de muestra. Este código implementa el lado receptor y usa la API de Google Cloud Pub/Sub para extraer eventos a medida que están disponibles. Los distintos métodos de controlador imprimen información sobre los eventos correspondientes.

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

Finaliza el código

Agrega el siguiente código a main.py para llamar a los métodos que crean el espacio, se suscriben a los eventos y escuchan. Actualiza las constantes TOPIC_NAME y SUBSCRIPTION_NAME con tus propios nombres de temas y suscripciones que creaste anteriormente.

1. Agrega el código a 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)
   if (subscription.status_code) == 200:
       listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   else:
       print(f"Subscription to Meet events failed, response data: {subscription.content}")
   

   Reemplaza lo siguiente:

   • PROJECT_ID: Es el ID único del proyecto de Cloud para tu app, como my-sample-project-191923.

   • TOPIC_ID: Es el nombre del tema de Pub/Sub que creaste en tu proyecto de Cloud.

   • SUBSCRIPTION_ID: Es el nombre de tu suscripción, como workspace-events-sub.

2. Ejecuta el programa:

   python3 main.py

Si no ejecutaste el programa antes, se te solicitará autorización la primera vez. Otorga acceso a la aplicación para llamar a la API de REST de Meet. Después de que el programa se ejecute correctamente, deberías ver un resultado similar al siguiente:

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

Unirse a la conferencia

Para generar eventos para la aplicación, únete a la conferencia con la URL que muestra la aplicación. Después de unirte, puedes probar estas acciones para activar eventos:

• Abandona la reunión y vuelve a unirte a ella.
• Invita a otras personas o marca con tu teléfono.
• Habilita las grabaciones y transcripciones.

Cada una de estas actividades genera un evento que la aplicación recibe y registra en la consola de Google Cloud.

Usa ctrl-c para interrumpir el programa cuando termines.

Opcional: Pasos adicionales que puedes probar

La app registra detalles básicos sobre los eventos. Para seguir explorando la API de REST de Meet, intenta modificar la aplicación para que realice estas acciones adicionales.

• Usa la API de People para recuperar información adicional sobre los participantes que accedieron.

  def subscribe_to_user(user_name: str = None, topic_name: str = None) -> requests_lib.Response:
      """Subscribe to events for a user."""
      session = requests.AuthorizedSession(USER_CREDENTIALS)
      body = {
          "targetResource": f"//cloudidentity.googleapis.com/users/{user_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
  
  service = build("people", "v1", credentials=USER_CREDENTIALS)
  response = (
      service.people()
      .get(resourceName="people/me", personFields="names,emailAddresses")
      .execute()
  )
  resource_name = response.get("resourceName")
  if resource_name.startswith("people/"):
      resource_name = resource_name[len("people/") :]
  
  subscription = subscribe_to_user(topic_name=TOPIC_NAME, user_name=resource_name)
  

  Asegúrate de agregar "https://www.googleapis.com/auth/userinfo.profile" en el método de autorización en los ejemplos de credenciales anteriores.

• Usa la API de Google Drive para descargar grabaciones y transcripciones.

• En lugar de descargar transcripciones de Google Drive, recupéralas con los métodos de transcripción estructurada de la API de REST de Meet.

• Obtener espacio en lugar de crear el espacio

  def get_space(meeting_code: str) -> meet.Space:
      """Get a meeting space."""
      client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
      return client.get_space(name="spaces/" + meeting_code)
  

  Asegúrate de agregar "https://www.googleapis.com/auth/meetings.space.readonly" en el método de autorización en los ejemplos de credenciales anteriores.

Opcional: Limpieza

Para evitar que se apliquen cargos a tu cuenta de la consola de Google Cloud por los recursos que usaste en este instructivo, te recomendamos que limpies todos los recursos y proyectos que creaste.

Para borrar la suscripción, haz lo siguiente:

Para borrar el tema, sigue estos pasos:

Para borrar el proyecto, haz lo siguiente:

Temas relacionados

• Obtén información sobre los tipos de eventos de Meet a los que te puedes suscribir.
• Obtén más información sobre lo que puede hacer la API de REST de Google Meet y revisa la documentación de referencia.
• Crea una suscripción a Google Workspace para espacios de reuniones o usuarios de Meet con la API de Google Workspace Events.
• Para obtener más información sobre la autenticación, consulta Cómo configurar la pantalla de consentimiento de OAuth y elegir permisos.