Python और Google Meet REST API की मदद से, मीटिंग इवेंट देखें

इस ट्यूटोरियल में, Google Meet REST API के साथ-साथ Google Workspace Events API और Google Cloud Pub/Sub का इस्तेमाल करने का तरीका बताया गया है. इससे, Meet मीटिंग स्पेस में होने वाले इवेंट को देखा जा सकता है और उन पर प्रतिक्रिया दी जा सकती है. सैंपल ऐप्लिकेशन, कॉन्फ़्रेंस शुरू और खत्म होने का समय रिकॉर्ड करता है. साथ ही, यह भी रिकॉर्ड करता है कि लोग कब शामिल हुए या कब मीटिंग छोड़ी. इसके अलावा, यह जनरेट किए गए मीटिंग के आर्टफ़ैक्ट की उपलब्धता की जानकारी भी रिकॉर्ड करता है.

किसी मीटिंग स्पेस की सदस्यता लेने के बजाय, Meet का इस्तेमाल करने वाले किसी व्यक्ति की सदस्यता ली जा सकती है. इससे आपको उस व्यक्ति के मालिकाना हक वाले या उसके बनाए गए किसी भी मीटिंग स्पेस के इवेंट की सूचनाएं मिलेंगी. ज़्यादा जानकारी के लिए, Google Workspace Events API के दस्तावेज़ में Google Meet इवेंट की सदस्यता लें लेख पढ़ें.

ज़रूरी शर्तें

अगर आपको अपने संगठन के लिए इनमें से किसी सुविधा को चालू करना है, तो अपने Google Workspace एडमिन से इसे चालू करने के लिए कहें:

• Google Workspace खाता, जिसमें Google Meet का ऐक्सेस हो.
• Google Cloud प्रोजेक्ट बनाने का ऐक्सेस.
• Python 3 इंस्टॉल हो.
• gcloud सीएलआई इंस्टॉल हो.

अपना एनवायरमेंट तैयार करना

इस सेक्शन में, इस ट्यूटोरियल के लिए लोकल एनवायरमेंट और Google Cloud प्रोजेक्ट बनाने और कॉन्फ़िगर करने का तरीका बताया गया है.

वर्किंग डायरेक्ट्री और Python वर्चुअल एनवायरमेंट बनाना

नया वर्चुअल एनवायरमेंट बनाने और उसे चालू करने के लिए, अपने टर्मिनल में यहां दिए गए निर्देश चलाएं.

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

Google Cloud प्रोजेक्ट बनाना

Google Cloud प्रोजेक्ट के लिए बिलिंग की सुविधा चालू करना

पुष्टि करने और अनुमति देने की सुविधा सेट अप करना

पुष्टि करने और अनुमति देने की प्रोसेस से, ऐप्लिकेशन को Meet REST API के संसाधनों को ऐक्सेस करने की अनुमति मिलती है. Meet REST API को कॉल करने के लिए, उपयोगकर्ता की अनुमति ज़रूरी है. इस सेक्शन में, उपयोगकर्ता के क्रेडेंशियल कॉन्फ़िगर करने और अनुमति का अनुरोध करने का तरीका बताया गया है.

OAuth के लिए सहमति देने वाली स्क्रीन को कॉन्फ़िगर करना और स्कोप चुनना

यहां दिए गए तरीके में, आपके ऐप्लिकेशन के लिए OAuth सहमति स्क्रीन को कॉन्फ़िगर करने के लिए, प्लेसहोल्डर की जानकारी दी गई है. ऐप्लिकेशन को बाहरी तौर पर पब्लिश करने से पहले, इस जानकारी को अपडेट करें.

1. Google Cloud Console में, मेन्यू menu &gt Google Auth platform &gt ब्रैंडिंग पर जाएं.

   ब्रैंडिंग पर जाएं

2. अगर आपने पहले ही Google Auth platformको कॉन्फ़िगर कर लिया है, तो ब्रैंडिंग, दर्शक, और डेटा ऐक्सेस में जाकर, OAuth सहमति स्क्रीन की इन सेटिंग को कॉन्फ़िगर किया जा सकता है. अगर आपको Google Auth platform अभी तक कॉन्फ़िगर नहीं किया गया है मैसेज दिखता है, तो शुरू करें पर क्लिक करें:
1. ऐप्लिकेशन की जानकारी में जाकर, ऐप्लिकेशन का नाम में Meet REST API Tutorial डालें.
2. उपयोगकर्ता सहायता के लिए ईमेल पता में, सहायता के लिए वह ईमेल पता चुनें जिस पर उपयोगकर्ता, सहमति से जुड़े सवालों के लिए आपसे संपर्क कर सकें.
3. आगे बढ़ें पर क्लिक करें.
4. दर्शक सेक्शन में जाकर, संगठन के अंदर से जनरेट होने वाला ट्रैफ़िक चुनें.
5. आगे बढ़ें पर क्लिक करें.
6. संपर्क जानकारी में जाकर, वह ईमेल पता डालें जिस पर आपको अपने प्रोजेक्ट में हुए किसी भी बदलाव की सूचना मिल सके.
7. आगे बढ़ें पर क्लिक करें.
8. पूरा करें में जाकर, Google API सेवाओं के उपयोगकर्ता के डेटा की नीति पढ़ें. अगर आप इससे सहमत हैं, तो मैं Google API सेवाओं के उपयोगकर्ता के डेटा की नीति से सहमत हूं को चुनें.
9. जारी रखें पर क्लिक करें.
10. बनाएं पर क्लिक करें.
11. अगर आपने उपयोगकर्ता के टाइप के लिए बाहरी चुना है, तो टेस्टर जोड़ें:
    1. ऑडियंस पर क्लिक करें.
    2. टेस्ट उपयोगकर्ता में जाकर, उपयोगकर्ता जोड़ें पर क्लिक करें.
    3. अपना ईमेल पता और टेस्ट के लिए अनुमति पा चुके अन्य उपयोगकर्ताओं के ईमेल पते डालें. इसके बाद, सेव करें पर क्लिक करें.
3. डेटा ऐक्सेस > स्कोप जोड़ें या हटाएं पर क्लिक करें. एक पैनल दिखता है. इसमें, आपके Google Cloud प्रोजेक्ट में चालू किए गए हर एपीआई के लिए, स्कोप की सूची होती है.
4. स्कोप मैन्युअल तरीके से जोड़ें सेक्शन में जाकर, ये स्कोप चिपकाएं:
   • https://www.googleapis.com/auth/meetings.space.created
5. टेबल में जोड़ें पर क्लिक करें.
6. अपडेट करें पर क्लिक करें.
7. आपके ऐप्लिकेशन के लिए ज़रूरी स्कोप चुनने के बाद, सेव करें पर क्लिक करें.

OAuth की सहमति को कॉन्फ़िगर करने के बारे में ज़्यादा जानने के लिए, Google Auth platformका इस्तेमाल शुरू करना लेख पढ़ें.

क्लाइंट आईडी बनाना

OAuth 2.0 फ़्लो के दौरान, क्लाइंट आईडी आपके ऐप्लिकेशन के क्रेडेंशियल के तौर पर काम करता है. ऐप्लिकेशन को स्थानीय तौर पर चलाया जाता है. इसलिए, डेस्कटॉप क्लाइंट आईडी बनाएं.

1. Google Cloud console में, मेन्यू menu > Google Auth platform > क्लाइंट पर जाएं.

   क्लाइंट पर जाएं

2. क्लाइंट बनाएं पर क्लिक करें.
3. ऐप्लिकेशन का टाइप > डेस्कटॉप ऐप्लिकेशन पर क्लिक करें.
4. नाम फ़ील्ड में, क्रेडेंशियल के लिए कोई नाम टाइप करें. यह नाम सिर्फ़ Google Cloud Console में दिखता है.
5. बनाएं पर क्लिक करें.

   नया क्रेडेंशियल, "OAuth 2.0 क्लाइंट आईडी" में दिखता है.

Google की पुष्टि करने वाली लाइब्रेरी इंस्टॉल करना

Google की पुष्टि करने वाली लाइब्रेरी इंस्टॉल करें:

pip install google-auth google-auth-oauthlib

अनुमति लागू करना

Meet REST API को OAuth 2.0 ऐक्सेस टोकन के तौर पर उपयोगकर्ता क्रेडेंशियल की ज़रूरत होती है. इस सेक्शन में, OAuth 2.0 फ़्लो लागू किया जाता है. इससे उपयोगकर्ता के लिए ऐक्सेस टोकन और रीफ़्रेश टोकन का अनुरोध किया जा सकता है.

1. अपनी वर्किंग डायरेक्ट्री में, main.py फ़ाइल बनाएं और इसमें यह कॉन्टेंट जोड़ें:

   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. कोड चलाने के लिए, पहले बनाए गए क्लाइंट आईडी और सीक्रेट, दोनों की ज़रूरत होती है. डाउनलोड की गई क्लाइंट सीक्रेट फ़ाइल को प्रोजेक्ट की वर्किंग डायरेक्ट्री में कॉपी करें और उसका नाम बदलकर client_secret.json कर दें.

3. अगर आपको यह जांच करनी है कि अनुमति देने की सुविधा कैसे काम करती है, तो यह कमांड चलाएं. अनुरोध स्वीकार होने के बाद, ऐप्लिकेशन अनुमति के लिए प्रॉम्प्ट करता है और प्रोजेक्ट की वर्किंग डायरेक्ट्री में token.json फ़ाइल बनाता है.

   python3 main.py

Meet REST API जोड़ना

अब आपने ऑथराइज़ेशन कोड जनरेट कर लिया है. इसलिए, अब Meet REST API को चालू करें और कॉल करें.

एपीआई चालू करना

इस सेक्शन में Meet REST API पर फ़ोकस किया गया है. हालांकि, इस ट्यूटोरियल में Google Cloud Pub/Sub और Google Workspace Events API का भी इस्तेमाल किया गया है.

Meet REST API की क्लाइंट लाइब्रेरी इंस्टॉल करना

Meet REST API क्लाइंट लाइब्रेरी इंस्टॉल करने के लिए, यह तरीका अपनाएं:

1. यह कमांड चलाएं:

   pip install google-apps-meet

2. क्लाइंट को इंपोर्ट करने के लिए, main.py फ़ाइल में बदलाव करें:

   from google.apps import meet_v2 as meet
   

कोई स्पेस बनाना

Meet REST API उपलब्ध होने के बाद, मीटिंग स्पेस बनाने के लिए एक फ़ंक्शन तय करें. इस स्पेस की सदस्यता ली जा सकती है.

main.py में बदलाव करें और ये जोड़ें:

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

इवेंट के लिए सदस्यता लेना

मीटिंग स्पेस के बारे में इवेंट पाने के लिए, Google Workspace Events API का इस्तेमाल करके सदस्यता बनाई जाती है. आपको Google Cloud Pub/Sub विषय भी बनाना होगा और उसकी सदस्यता लेनी होगी. यह विषय, सूचना एंडपॉइंट के तौर पर काम करता है. इस एंडपॉइंट पर आपका ऐप्लिकेशन इवेंट पाता है.

Google Cloud Pub/Sub को कॉन्फ़िगर करना

Pub/Sub विषय बनाने और उसकी सदस्यता लेने के लिए:

विषय का नाम नोट करें. साथ ही, पक्का करें कि {project} की वैल्यू, आपके ऐप्लिकेशन के लिए Cloud प्रोजेक्ट आईडी हो. आपको विषय के नाम का इस्तेमाल, बाद में Google Workspace सदस्यता बनाने के लिए करना होगा.

सेवा खाता बनाना

सेवा खाते का इस्तेमाल करना

सेवा खाता बनाने के बाद, खुद को सेवा खाते के तौर पर काम करने का ऐक्सेस दें.

Pub/Sub क्लाइंट लाइब्रेरी इंस्टॉल करना

1. Pub/Sub के लिए क्लाइंट लाइब्रेरी इंस्टॉल करने के लिए, pip का इस्तेमाल करें:

   pip install google-cloud-pubsub

2. इसके बाद, क्लाइंट को इंपोर्ट करने के लिए main.py में बदलाव करें:

   from google.cloud import pubsub_v1
   

Google Workspace की सदस्यता बनाना

main.py में यह कोड जोड़ें, ताकि Meet इवेंट की सदस्यता लेने का तरीका तय किया जा सके. यह कोड, मीटिंग स्पेस के सभी इवेंट के लिए सदस्यता लेता है. सदस्यता लेने पर, इवेंट को 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

इसके बाद, इवेंट को पुल और प्रोसेस करने के लिए, उससे जुड़ा कोड जोड़ें.

इवेंट को सुनना और उन्हें मैनेज करना

main.py में बदलाव करना जारी रखें और यहां दिया गया सैंपल कोड जोड़ें. यह कोड, इवेंट पाने वाले पक्ष को लागू करता है. साथ ही, उपलब्ध होने पर इवेंट पाने के लिए, Google Cloud Pub/Sub API का इस्तेमाल करता है. हैंडलर के अलग-अलग तरीके, इवेंट से जुड़ी जानकारी प्रिंट करते हैं.

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

कोड को फ़ाइनल करना

स्पेस बनाने, इवेंट की सदस्यता लेने, और सुनने के लिए तरीकों को कॉल करने के लिए, main.py में यह कोड जोड़ें. TOPIC_NAME और SUBSCRIPTION_NAME कॉन्स्टेंट को अपने बनाए गए विषय और सदस्यता के नामों से अपडेट करें.

1. 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}")
   

   इनकी जगह ये डालें:

   • PROJECT_ID: आपके ऐप्लिकेशन के लिए यूनीक Cloud प्रोजेक्ट आईडी, जैसे कि my-sample-project-191923.

   • TOPIC_ID: यह उस Pub/Sub विषय का नाम है जिसे आपने Cloud प्रोजेक्ट में बनाया है.

   • SUBSCRIPTION_ID: आपकी सदस्यता का नाम, जैसे कि workspace-events-sub.

2. प्रोग्राम चलाएं:

   python3 main.py

अगर आपने पहले कभी इस प्रोग्राम का इस्तेमाल नहीं किया है, तो पहली बार में आपसे अनुमति मांगी जाएगी. ऐप्लिकेशन को Meet REST API को कॉल करने का ऐक्सेस दें. प्रोग्राम के सही तरीके से चलने के बाद, आपको इससे मिलता-जुलता आउटपुट दिखेगा:

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

कॉन्फ़्रेंस में शामिल होना

ऐप्लिकेशन के लिए इवेंट जनरेट करने के लिए, ऐप्लिकेशन में दिखाए गए यूआरएल का इस्तेमाल करके कॉन्फ़्रेंस में शामिल हों. शामिल होने के बाद, इवेंट ट्रिगर करने के लिए ये कार्रवाइयां करके देखें:

• मीटिंग छोड़ें और इसमें फिर से शामिल हों.
• दूसरे लोगों को न्योता भेजें या अपने फ़ोन से डायल इन करें.
• रिकॉर्डिंग और ट्रांसक्रिप्ट की सुविधा चालू करें.

इनमें से हर गतिविधि से एक इवेंट जनरेट होता है. ऐप्लिकेशन को यह इवेंट मिलता है और वह इसे Google Cloud Console में लॉग करता है.

जब आपका काम पूरा हो जाए, तो प्रोग्राम को रोकने के लिए ctrl-c का इस्तेमाल करें.

ज़रूरी नहीं: समस्या को हल करने के अन्य तरीके

यह ऐप्लिकेशन, इवेंट के बारे में बुनियादी जानकारी लॉग करता है. Meet REST API के बारे में ज़्यादा जानने के लिए, ऐप्लिकेशन में बदलाव करके इन अतिरिक्त कार्रवाइयों को आज़माएं.

• साइन इन किए हुए लोगों के बारे में ज़्यादा जानकारी पाने के लिए, People API का इस्तेमाल करें.

  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)
  

  ऊपर दिए गए क्रेडेंशियल के सैंपल में, authorize method में "https://www.googleapis.com/auth/userinfo.profile" जोड़ना न भूलें.

• रिकॉर्डिंग और ट्रांसक्रिप्ट डाउनलोड करने के लिए, Google Drive API का इस्तेमाल करें.

• Google Drive से ट्रांसक्रिप्ट डाउनलोड करने के बजाय, Meet REST API में स्ट्रक्चर्ड ट्रांसक्रिप्ट के तरीकों का इस्तेमाल करके उन्हें वापस पाएं.

• स्पेस बनाने के बजाय, स्पेस का ऐक्सेस पाना

  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)
  

  ऊपर दिए गए क्रेडेंशियल के सैंपल में, authorize method में "https://www.googleapis.com/auth/meetings.space.readonly" को जोड़ना न भूलें.

ज़रूरी नहीं: साफ़ करना

इस ट्यूटोरियल में इस्तेमाल किए गए संसाधनों के लिए, Google Cloud Console खाते से शुल्क न लिया जाए, इसके लिए हमारा सुझाव है कि आप बनाए गए सभी संसाधनों और प्रोजेक्ट को हटा दें.

सदस्यता मिटाने के लिए:

विषय मिटाने के लिए:

प्रोजेक्ट मिटाने के लिए:

मिलते-जुलते विषय

• Meet के उन इवेंट के बारे में जानें जिनकी सूचना पाने के लिए सदस्यता ली जा सकती है.
• Google Meet REST API की सुविधाओं के बारे में ज़्यादा जानें. साथ ही, रेफ़रंस दस्तावेज़ देखें.
• Google Workspace Events API का इस्तेमाल करके, Meet मीटिंग स्पेस या उपयोगकर्ताओं के लिए Google Workspace की सदस्यता लें.
• पुष्टि करने के बारे में ज़्यादा जानने के लिए, OAuth के लिए सहमति लेने वाली स्क्रीन को कॉन्फ़िगर करना और स्कोप चुनना लेख पढ़ें.