Python क्विकस्टार्ट

क्विकस्टार्ट उस ऐप्लिकेशन को सेट अप करने और चलाने का तरीका बताता है जो Google Workspace API को कॉल करता है.

Google Workspace क्विकस्टार्ट, पुष्टि करने और अनुमति देने की प्रोसेस से जुड़ी कुछ जानकारी को मैनेज करने के लिए, एपीआई क्लाइंट लाइब्रेरी का इस्तेमाल करता है. हमारा सुझाव है कि आप अपने ऐप्लिकेशन के लिए, क्लाइंट लाइब्रेरी का इस्तेमाल करें. यह क्विकस्टार्ट, पुष्टि करने के आसान तरीके का इस्तेमाल करता है. यह टेस्ट एनवायरमेंट के लिए सही है. प्रोडक्शन एनवायरमेंट के लिए, हमारा सुझाव है कि अपने ऐप्लिकेशन के लिए सही ऐक्सेस क्रेडेंशियल चुनने से पहले, पुष्टि करने और अनुमति देने के बारे में जानें.

ऐसा Python कमांड-लाइन ऐप्लिकेशन बनाएं जो Google Apps Script API को अनुरोध भेज सके.

मकसद

• अपना एनवायरमेंट सेट अप करें.
• क्लाइंट लाइब्रेरी इंस्टॉल करें.
• सैंपल सेट अप करें.
• सैंपल चलाएं.

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

इस क्विकस्टार्ट को चलाने के लिए, आपको इन शर्तों का पालन करना होगा:

• Python 3.10.7 या इससे नया वर्शन
• pip पैकेज मैनेजमेंट टूल
• Google Cloud प्रोजेक्ट.

• आपके पास Google Drive वाला Google खाता हो.

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

इस क्विकस्टार्ट को पूरा करने के लिए, अपना एनवायरमेंट सेट अप करें.

एपीआई चालू करें

Google API का इस्तेमाल करने से पहले, आपको उन्हें Google Cloud प्रोजेक्ट में चालू करना होगा. किसी एक Google Cloud प्रोजेक्ट में, एक या उससे ज़्यादा एपीआई चालू किए जा सकते हैं.

• Google Cloud कंसोल में, Google Apps Script API को चालू करें.

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

उस स्क्रीन को कॉन्फ़िगर करना जहां OAuth के लिए सहमति दी जाती है

अगर इस क्विकस्टार्ट को पूरा करने के लिए, किसी नए Google Cloud प्रोजेक्ट का इस्तेमाल किया जा रहा है, तो OAuth के लिए सहमति देने वाली स्क्रीन को कॉन्फ़िगर करें और खुद को टेस्ट उपयोगकर्ता के तौर पर जोड़ें. अगर आपने अपने Cloud प्रोजेक्ट के लिए यह चरण पहले ही पूरा कर लिया है, तो अगले सेक्शन पर जाएं.

1. Google Cloud Console में, मेन्यू > एपीआई और सेवाएं > OAuth की सहमति वाली स्क्रीन पर जाएं.

   ऐसी स्क्रीन पर जाएं जहां OAuth के लिए सहमति दी जाती है

2. उपयोगकर्ता टाइप के लिए, अंदरूनी चुनें. इसके बाद, बनाएं पर क्लिक करें.
3. ऐप्लिकेशन रजिस्ट्रेशन फ़ॉर्म भरें. इसके बाद, सेव करें और जारी रखें पर क्लिक करें.

4. फ़िलहाल, दायरों को छोड़कर आगे बढ़ा जा सकता है. साथ ही, सेव करें और जारी रखें पर क्लिक करें. आने वाले समय में, जब अपने Google Workspace संगठन से बाहर इस्तेमाल करने के लिए कोई ऐप्लिकेशन बनाया जाएगा, तो आपको उपयोगकर्ता टाइप को बाहरी उपयोगकर्ता में बदलना होगा. इसके बाद, आपको अपने ऐप्लिकेशन के लिए ज़रूरी अनुमति के दायरे जोड़ने होंगे.

5. अपने ऐप्लिकेशन रजिस्ट्रेशन की खास जानकारी देखें. बदलाव करने के लिए, बदलाव करें पर क्लिक करें. अगर ऐप्लिकेशन रजिस्ट्रेशन ठीक लग रहा है, तो डैशबोर्ड पर वापस जाएं पर क्लिक करें.

डेस्कटॉप ऐप्लिकेशन के लिए क्रेडेंशियल की पुष्टि करना

असली उपयोगकर्ताओं की पुष्टि करने और अपने ऐप्लिकेशन में उपयोगकर्ता का डेटा ऐक्सेस करने के लिए, आपको एक या उससे ज़्यादा OAuth 2.0 क्लाइंट आईडी बनाने होंगे. Client-ID का इस्तेमाल, Google के OAuth सर्वर पर किसी एक ऐप्लिकेशन की पहचान करने के लिए किया जाता है. अगर आपका ऐप्लिकेशन एक से ज़्यादा प्लैटफ़ॉर्म पर चलता है, तो आपको हर प्लैटफ़ॉर्म के लिए अलग-अलग क्लाइंट आईडी बनाना होगा.

1. Google Cloud Console में, मेन्यू > एपीआई और सेवाएं > क्रेडेंशियल पर जाएं.

   क्रेडेंशियल पर जाएं

2. क्रेडेंशियल बनाएं > OAuth क्लाइंट आईडी पर क्लिक करें.
3. ऐप्लिकेशन प्रकार > डेस्कटॉप ऐप्लिकेशन पर क्लिक करें.
4. नाम फ़ील्ड में, क्रेडेंशियल के लिए नाम लिखें. यह नाम सिर्फ़ Google Cloud Console में दिखता है.
5. बनाएं पर क्लिक करें. अब OAuth क्लाइंट की स्क्रीन पर आपका नया क्लाइंट आईडी और क्लाइंट सीक्रेट दिखेगा.
6. ठीक है पर क्लिक करें. नया क्रेडेंशियल, OAuth 2.0 Client ID में दिखता है.
7. डाउनलोड की गई JSON फ़ाइल को credentials.json के तौर पर सेव करें और उसे अपनी वर्क डायरेक्ट्री में ले जाएं.

Google क्लाइंट लाइब्रेरी इंस्टॉल करना

• Python के लिए Google क्लाइंट लाइब्रेरी इंस्टॉल करना:

  pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib
  

सैंपल कॉन्फ़िगर करें

1. अपनी वर्किंग डायरेक्ट्री में, quickstart.py नाम की एक फ़ाइल बनाएं.

2. quickstart.py में यह कोड शामिल करें:

   apps_script/quickstart/quickstart.py

   GitHub पर देखें

   """
   Shows basic usage of the Apps Script API.
   Call the Apps Script API to create a new script project, upload a file to the
   project, and log the script's URL to the user.
   """
   import os.path
   
   from google.auth.transport.requests import Request
   from google.oauth2.credentials import Credentials
   from google_auth_oauthlib.flow import InstalledAppFlow
   from googleapiclient import errors
   from googleapiclient.discovery import build
   
   # If modifying these scopes, delete the file token.json.
   SCOPES = ["https://www.googleapis.com/auth/script.projects"]
   
   SAMPLE_CODE = """
   function helloWorld() {
     console.log("Hello, world!");
   }
   """.strip()
   
   SAMPLE_MANIFEST = """
   {
     "timeZone": "America/New_York",
     "exceptionLogging": "CLOUD"
   }
   """.strip()
   
   
   def main():
     """Calls the Apps Script API."""
     creds = None
     # The file token.json stores the user's access and refresh tokens, and is
     # created automatically when the authorization flow completes for the first
     # time.
     if os.path.exists("token.json"):
       creds = Credentials.from_authorized_user_file("token.json", SCOPES)
     # If there are no (valid) credentials available, let the user log in.
     if not creds or not creds.valid:
       if creds and creds.expired and creds.refresh_token:
         creds.refresh(Request())
       else:
         flow = InstalledAppFlow.from_client_secrets_file(
             "credentials.json", SCOPES
         )
         creds = flow.run_local_server(port=0)
       # Save the credentials for the next run
       with open("token.json", "w") as token:
         token.write(creds.to_json())
   
     try:
       service = build("script", "v1", credentials=creds)
   
       # Call the Apps Script API
       # Create a new project
       request = {"title": "My Script"}
       response = service.projects().create(body=request).execute()
   
       # Upload two files to the project
       request = {
           "files": [
               {"name": "hello", "type": "SERVER_JS", "source": SAMPLE_CODE},
               {
                   "name": "appsscript",
                   "type": "JSON",
                   "source": SAMPLE_MANIFEST,
               },
           ]
       }
       response = (
           service.projects()
           .updateContent(body=request, scriptId=response["scriptId"])
           .execute()
       )
       print("https://script.google.com/d/" + response["scriptId"] + "/edit")
     except errors.HttpError as error:
       # The API encountered a problem.
       print(error.content)
   
   
   if __name__ == "__main__":
     main()

सैंपल चलाएं

1. अपनी वर्किंग डायरेक्ट्री में, यह सैंपल बनाएं और चलाएं:

   python3 quickstart.py
   

2. पहली बार सैंपल चलाने पर, यह आपको ऐक्सेस की अनुमति देने का अनुरोध करता है:
   1. अगर आपने अपने Google खाते में पहले से साइन इन नहीं किया है, तो मांगे जाने पर साइन इन करें. अगर आपने एक से ज़्यादा खातों में साइन इन किया हुआ है, तो अनुमति देने के लिए एक खाता चुनें.
   2. स्वीकार करें पर क्लिक करें.

   आपका Python ऐप्लिकेशन, Google Apps Script API को चलाता और कॉल करता है.

   अनुमति की जानकारी, फ़ाइल सिस्टम में सेव की जाती है. इसलिए, अगली बार सैंपल कोड चलाने पर, आपसे अनुमति लेने के लिए नहीं कहा जाता.

अगले चरण

• Apps Script API के रेफ़रंस दस्तावेज़
• Python दस्तावेज़ के लिए Google API क्लाइंट
• Google Apps Script API PyDoc दस्तावेज़