דף זה תורגם על ידי Cloud Translation API.

מדריך למפתחים: Python

YouTube Data API מאפשר לאפליקציות לקוח לאחזר ולעדכן תוכן של YouTube בצורת פידים של Google Data API. אפליקציית הלקוח יכולה להשתמש בפידים של YouTube Data API כדי לאחזר, לחפש ולעדכן סרטונים, תגובות, תשובות, פלייליסטים, פרופילי משתמשים ואנשי קשר של משתמשים, וגם להריץ שאילתות לגבי סרטונים שתואמים לקריטריונים מסוימים.

בנוסף למידע על היכולות של YouTube Data API, במסמך הזה מפורטות דוגמאות לאינטראקציה עם ה-API באמצעות ספריית הלקוח של Python. כדי להשתמש בספריית הלקוח של Python, צריך Python מגרסה 2.0 ואילך, ואת המודולים Element Tree, ‏ httplib ו-urllib. פרטים נוספים זמינים במאמר מודולים של יחסי תלות.

אם אתם זקוקים לעזרה בהגדרה של ספריית הלקוח של Python, תוכלו להיעזר במדריך למתחילים. מידע נוסף על הפרוטוקול הבסיסי שבו נעשה שימוש בספריית הלקוח של Python כדי ליצור אינטראקציה עם YouTube זמין בדף הפרוטוקול במדריך למפתחים.

מידע על המסמך הזה

קהל

המסמך הזה מיועד למתכנתים שרוצים לכתוב אפליקציות לקוח שיכולות ליצור אינטראקציה עם YouTube באמצעות ספריית הלקוח של Python. הוא כולל סדרה של דוגמאות לאינטראקציות בסיסיות של ממשקי API לנתונים.

מידע על YouTube Data API זמין במדריך העזרה.

במסמך הזה אנו מניחים שאתם מבינים את הרעיונות הכלליים שמאחורי פרוטוקול Google Data APIs, ושאתם יודעים לתכנת ב-Python.

למידע על הכיתות והשיטות של Python, אפשר לעיין ב-pyDocs (לכיתת השירות ולכיתות הנתונים) שכלולים בקוד המקור.

מבנה המסמך

המסמך הזה מכיל את הקטעים הבאים:

בקטע אימות מתוארות שתי שיטות האימות השונות שזמינות לשיוך פעולות API לחשבון משתמש ספציפי. בקטע הזה מפורטים גם ההבדלים בין האימות של YouTube Data API לבין ממשקי Google Data API אחרים. במסמך הזה, בהסברים על פונקציות ספציפיות של ממשקי API יצוין בבירור אם הפונקציה דורשת אימות משתמש. באופן כללי, כל הבקשות לשינוי נתוני סרטונים או פידים צריכות לעבור אימות. בקשות לקריאה בלבד של סרטונים גלויים לכולם לא מחייבות אימות.
בקטע הסבר על פידים ועל רשומות של סרטונים מוצגת תגובת API לדוגמה, ומוסבר איך לחלץ מידע על סרטון יחיד מרשימת סרטונים או מקבוצה של תוצאות חיפוש. בקטע הזה נסביר גם איך לגשת למטא-נתונים של רשומה ספציפית של סרטון. בסיום, בקטע הזה נסביר את המנגנון לעדכון של רשומה של סרטון ספציפי.
בקטע אחזור וסינון של סרטונים מוסבר איך לאחזר רשימות ספציפיות של סרטונים, כמו פיד רגיל של הסרטונים הפופולריים ביותר ב-YouTube. רשימות אחרות של סרטונים כוללות סרטונים שהועלו על ידי משתמש ספציפי ורשימות של סרטונים שקשורים לסרטון מסוים. בקטע הזה נסביר גם איך להשתמש ב-API כדי לאפשר למשתמשים לחפש בספריית הסרטונים של YouTube לפי מונחי חיפוש או קטגוריות ספציפיים.
בקטע העלאת סרטונים מוסבר בקצרה על שתי דרכים שבהן אפשר לאפשר למשתמשים להעלות סרטונים ל-YouTube מהאפליקציה שלכם. בנוסף, בקטע הזה נסביר איך להעלות סרטונים בתור תגובות לסרטונים אחרים.
בקטע עדכון וסימון סרטונים למחיקה מוסבר איך משתמשים ב-API כדי לעדכן מידע על סרטון ב-YouTube. בנוסף, מוסבר איך אפשר להסיר סרטון באמצעות ה-API.
בקטע שימוש בתכונות הקהילה מתוארות פונקציות API שמאפשרות למשתמשים שלכם לקיים אינטראקציה עם סרטונים ב-YouTube. הפונקציות האלה מפורטות בבקשות לפרסום דירוג, תגובה או תלונה לגבי סרטון קיים. אפשר גם להשתמש ב-API כדי לאחזר רשימות של תגובות לסרטונים.
בקטע שמירה ואיסוף של סרטונים מוסבר איך להשתמש ב-API כדי לגשת לסרטונים המועדפים, לפלייליסטים של סרטונים ולמינויים לערוצי YouTube, ליצור אותם ולעדכן אותם. בנוסף, מוסבר איך לשנות פלייליסטים של סרטונים ואת הסרטונים המועדפים על ידי הוספה והסרה של סרטונים.
בקטע הפעלת אינטראקציה של משתמשים מוסבר איך להשתמש ב-API כדי לאחזר ולעדכן פרופילים של משתמשים. בקטע הזה מוסבר גם איך לאחזר, להוסיף, לעדכן ולמחוק אנשי קשר של משתמשים.

תחילת העבודה

דרישות

אפליקציית הלקוח יכולה להשתמש בפיד של YouTube Data API כדי לחפש, לאחזר ולעדכן סרטונים, תגובות, תשובות, פלייליסטים, מינויים, פרופילי משתמשים ועוד.

בנוסף למידע על היכולות של YouTube Data API, במסמך הזה מפורטות דוגמאות לאינטראקציה עם ה-API באמצעות ספריית הלקוח של Python. כדי להשתמש בספריית הלקוח של Python, צריך Python מגרסה 2.2 ואילך ואת המודולים Element Tree,‏ httplib ו-urllib. פרטים נוספים זמינים במאמר מודולים של יחסי תלות.

מידע נוסף על הגדרת הסביבה זמין במדריך לתחילת העבודה. מידע נוסף על הפרוטוקול הבסיסי שבו נעשה שימוש בספריית הלקוח של Python כדי ליצור אינטראקציה עם YouTube זמין בדף הפרוטוקול במדריך למפתחים.

אפשר להעתיק או להדביק את קטעי הקוד לדוגמה שבהמשך בקוד שלכם ולשנות אותם בהתאם לצרכים שלכם.

לפני שתוכלו לבצע פעולות כלשהן באמצעות YouTube Data API, עליכם לאתחל אובייקט gdata.youtube.service.YouTubeService, כפי שמתואר בהמשך. הצהרות import שמפורטות בהמשך יבצעו באופן אוטומטי ייבוא נוסף מהמודולים gdata.media ו-gdata.geo. לתשומת ליבכם: כל הפעולות, מלבד אחזור תוכן ציבורי, מחייבות אימות.

import gdata.youtube
import gdata.youtube.service

yt_service = gdata.youtube.service.YouTubeService()

# Turn on HTTPS/SSL access.
# Note: SSL is not available at this time for uploads.
yt_service.ssl = True

רוב הדוגמאות לשיטות במדריך הזה פועלות על מופע של gdata.youtube.service.YouTubeService. מומלץ לבדוק את הבקשות ללא אימות ממתורגמן Python אינטראקטיבי.

הערה: צריך להוסיף את ספריית הלקוח של Python בצורה נכונה בנתיב. חשוב לוודא שההתקנה בוצעה על ידי הפעלת הסקריפט setup.py שסופק. מידע נוסף זמין במדריך למתחילים.

אימות

אפשר להשתמש בספריית הלקוח של Python כדי לעבוד עם פידים ציבוריים או פרטיים. פידים ציבוריים הם לקריאה בלבד ולא דורשים אימות. כדי להשתמש בפידים פרטיים, צריך לבצע אימות בשרתי YouTube.

אפשר לבצע אימות באמצעות אימות ClientLogin (לאפליקציות למחשב) או באמצעות אימות AuthSub (לאפליקציות אינטרנט).

הגדרת מפתח הפיתוח ומזהה הלקוח

מפתח מפתח מזהה את מפתח YouTube ששולח בקשת API. מזהה לקוח מזהה את האפליקציה שלכם למטרות רישום ביומן וניפוי באגים.

כששולחים בקשת API באמצעות ספריית הלקוח של Python, כותרת הבקשה X-GData-Key משמשת לציון מפתח הפיתוח וכותרת X-GData-Client משמשת לציון מזהה הלקוח. אפשר להגדיר את מפתח המפתחות ואת מזהה הלקוח באובייקט YouTubeService, ללא קשר לסכמת האימות שבה נעשה שימוש:

yt_service.developer_key = 'ABCxyz123...'
yt_service.client_id = 'My-Client_id'

תצטרכו להירשם למפתח פיתוח של YouTube.

אימות AuthSub לאפליקציות אינטרנט

אימות שרת proxy של AuthSub משמש אפליקציות אינטרנט שצריכות לאמת את המשתמשים שלהן בחשבונות YouTube או Google. למפעיל אין צורך בגישה לשם המשתמש ולסיסמה של משתמש YouTube – נדרשים רק אסימוני AuthSub מיוחדים.

כשהמשתמש נכנס לאפליקציה בפעם הראשונה, הוא עדיין לא אומת באמצעות שירותי Google. במקרה כזה, צריך לספק להם קישור שיפנה את המשתמש אל Google כדי לאשר את הבקשה של האפליקציות שלכם לגישה לחשבון YouTube שלהם. ספריית הלקוח של Python מספקת פונקציה ליצירת כתובת ה-URL הזו. הקוד הבא מגדיר קישור לדף AuthSubRequest.

def GetAuthSubUrl():
  next = 'http://www.example.com/video_upload.pyc'
  scope = 'http://gdata.youtube.com'
  secure = False
  session = True

yt_service = gdata.youtube.service.YouTubeService()
return yt_service.GenerateAuthSubURL(next, scope, secure, session)

authSubUrl = GetAuthSubUrl()
print '<a href="%s">Login to your Google account</a>' % authSubUrl

שימו לב לפרמטרים שנשלחים לשיטה GenerateAuthSubURL של אובייקטי השירות:

next – כתובת ה-URL של הדף שאליו YouTube צריכה להפנות את המשתמש אחרי שהוא יאשר לאפליקציה שלכם גישה לחשבון שלו.
scope – מציין שהאפליקציה תקבל גישה רק לפידים של YouTube API.
secure – מציין שהאסימון שיוחזר לא יהיה אסימון מאובטח.
session – מציין שאפשר להמיר את הטוקן הזה לטוקן לשימוש רב-פעמי (סשן).

כתובת ה-URL שתוחזר תיראה בערך כך:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fgdata.youtube.com&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fvideo_upload.pyc

לאחר מכן, המשתמש יכול ללחוץ על הקישור כדי להתחבר לחשבון YouTube שלו. אחרי שהמשתמש יאשר לאפליקציה גישה לחשבון שלו, הוא יועבר לכתובת ה-URL next. כתובת ה-URL תכלול ערך אסימון לשימוש יחיד כפרמטר של שאילתה. כתובת ה-URL נראית בערך כך:

http://www.example.com/video_upload.pyc?token=Abc123...

בקטע הבא נסביר איך לשדרג את האסימון הזה. קטע הקוד הבא מדגים אחת מהדרכים לאחזר את האסימון הזה מכתובת ה-URL:

import cgi
parameters = cgi.FieldStorage()
authsub_token = parameters[[]'token' ]

שדרוג לטוקן סשן

מטעמי אבטחה, האסימון הזה מיועד לשימוש חד-פעמי בלבד. לכן, עכשיו צריך להחליף את האסימון לשימוש חד-פעמי באסימון סשן. התהליך הזה מתואר במסמכי AuthSub. בקטע הקוד הבא מוסבר איך לשדרג את האסימון.

yt_service = gdata.youtube.service.YouTubeService()
yt_service.SetAuthSubToken(authsub_token)
yt_service.UpgradeToSessionToken()

ערך האסימון הזה מייצג אסימון AuthSub לשימוש יחיד. מאחר ש-session = True צוין למעלה, אפשר להחליף את האסימון הזה באסימון סשן של AuthSub באמצעות השיטה UpgradeToSessionToken, שמפעילה את השירות AuthSubSessionToken.

האובייקט YouTubeService מאומת עכשיו באופן מלא, וניתן להשתמש בו כדי לבצע את כל הבקשות הבאות באמצעות YouTube API. התוקף של אסימוני הסשן של AuthSub לא יפוג אלא אם תשלחו בקשה ספציפית לביטול שלהם, או שהמשתמש יחליט לבטל את הגישה על ידי כניסה לדף אתרים מורשים בחשבון YouTube שלו.

אימות ClientLogin לאפליקציות מותקנות

אימות ClientLogin משמש באפליקציות מותקנות שיכולות לאחסן את שם המשתמש והסיסמה של המשתמש או לשלוח שאילתות אליו כדי לקבל אותם. כדי להשתמש בסוג האימות הזה, צריך להפעיל את השיטה ProgrammaticLogin של YouTubeService שעוברת בירושה מהקלאס gdata.service.GDataService, ולציין את המזהה והסיסמה של המשתמש בשם מי הלקוח שולח את הבקשה לאימות.

yt_service = gdata.youtube.service.YouTubeService()
yt_service.email = 'jo@gmail.com'
yt_service.password = 'mypassword'
yt_service.source = 'my-example-application'
yt_service.ProgrammaticLogin()

אחרי שמגדירים את פרטי הכניסה, אפשר להשתמש באובייקט YouTubeService כדי לטפל בכל הבקשות הבאות. כדי שתוכלו לבצע העלאות וכל סוג של בקשות 'כתיבה' (הוספת תגובות וכו') ל-YouTube API, חשוב לוודא שאתם מעבירים גם את מפתח המפתחות ואת מזהה הלקוח שלכם לאובייקט yt_service כשאתם מבצעים אימות:

# A complete client login request
yt_service.email = 'jo@gmail.com'
yt_service.password = 'mypassword'
yt_service.source = 'my-example-application'
yt_service.developer_key = 'ABC123...'
yt_service.client_id = 'my-example-application'
yt_service.ProgrammaticLogin()

האובייקט YouTubeService מגדיר באופן אוטומטי את הכותרות הנכונות X-GData-Key ו-X-GData-Client כשמגדירים את המאפיינים developer_key ו-client_id.

הערה: מידע מפורט יותר על המנגנונים של AuthSub ו-ClientLogin זמין במסמכי העזרה בנושא אימות של Google Data APIs.

הסבר על פידים ורשומות של סרטונים

‏YouTube Data API מספק כמה פידים של סרטונים שמייצגים רשימות של סרטונים, כמו פידים רגילים, העלאות, מינויים ומועדפים. כתובת ה-URL של כל פיד מתועדת במדריך העזרה.

הצגת פיד של סרטונים

פידים רבים ב-YouTube API מורכבים מרשאות של סרטונים. הדרך הפשוטה ביותר ליצור מודל של הפידים האלה היא כאובייקטים מסוג gdata.youtube.YouTubeVideoFeed, שכל אחד מהם מכיל מספר אובייקטים מסוג gdata.youtube.YouTubeVideoEntry. כל רשומת סרטון תואמת לסרטון אחד בלבד ב-YouTube ומכילה מידע על הסרטון.

המבנה הבסיסי של אחזור רשימת סרטונים הוא יצירה של כתובת URL של פיד וידאו, ולאחר מכן עיבוד הרשומות אחת אחרי השנייה, בדומה לקוד הבא:

def GetAndPrintVideoFeed(uri):
  yt_service = gdata.youtube.service.YouTubeService()
  feed = yt_service.GetYouTubeVideoFeed(uri)
  for entry in feed.entry:
    PrintEntryDetails(entry) # full documentation for this function

בקטע אחזור וסינון של סרטונים מפורטות כתובות URL נפוצות רבות של פידים, ומוסבר איך לאחזר פידים שונים של סרטונים.

אחזור של רשומת סרטון ספציפית

אם אתם יודעים את מזהה הסרטון, אתם יכולים לאחזר רק את המידע לגבי רשומת סרטון ספציפית. כתובת ה-URL של הרשומה מבוססת על מזהה הסרטון:

http://gdata.youtube.com/feeds/api/videos/videoID

הקוד הבא מאחזר את הערך של gdata.youtube.YouTubeVideoEntry שתואם לסרטון ב-YouTube:

entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')

תוכן הסרטון ששולחים

יש הרבה פריטים של מטא-נתונים שאפשר לאחזר מאובייקט gdata.youtube.YouTubeVideoEntry, כמו תמונות ממוזערות, כתובות URL של נגנים ומשך הסרטון. הקוד הבא מראה איך אפשר לגשת לחלק מהמידע הזה. ספריית הלקוח של Python מסנכרנת את רוב הפונקציונליות הזו על ידי מיפוי רכיבי XML לכיתות. רוב המידע החשוב על רשומה YouTubeVideoEntry זמין מהצאצאים של המאפיין media (שמכיל אובייקט gdata.media.Group) בתוך הרשומה (שמייצגת את הרכיב media:group ב-XML). בהמשך מופיעה דוגמה לאחזור מטא-נתונים של סרטון:

def PrintEntryDetails(entry):
  print 'Video title: %s' % entry.media.title.text
  print 'Video published on: %s ' % entry.published.text
  print 'Video description: %s' % entry.media.description.text
  print 'Video category: %s' % entry.media.category[[]0].text
  print 'Video tags: %s' % entry.media.keywords.text
  print 'Video watch page: %s' % entry.media.player.url
  print 'Video flash player URL: %s' % entry.GetSwfUrl()
  print 'Video duration: %s' % entry.media.duration.seconds

  # non entry.media attributes
  print 'Video geo location: %s' % entry.geo.location()
  print 'Video view count: %s' % entry.statistics.view_count
  print 'Video rating: %s' % entry.rating.average

  # show alternate formats
  for alternate_format in entry.media.content:
    if 'isDefault' not in alternate_format.extension_attributes:
      print 'Alternate format: %s | url: %s ' % (alternate_format.type,
                                                 alternate_format.url)

  # show thumbnails
  for thumbnail in entry.media.thumbnail:
    print 'Thumbnail url: %s' % thumbnail.url

הערה: מידע נוסף על יצירת המידע הנדרש להטמעת סרטון עם נגן בדף זמין במדריך לפרוטוקול.

אחזור וסינון של סרטונים

אחזור פידים רגילים

YouTube Data API מספק פיד רגיל של הסרטונים הפופולריים ביותר ב-YouTube. בעבר ה-API תמך בפידים רגילים אחרים, שהוצאו משימוש. מידע נוסף זמין במדריך למפתחים.

כתובת ה-URL של הפיד של הסרטונים הפופולריים ביותר ב-YouTube היא בפורמט הבא:

http://gdata.youtube.com/feeds/api/standardfeeds/most_popular

הערה: אפשר גם לאחזר פידים רגילים שמותאמים לאזור גיאוגרפי ספציפי על ידי ציון מזהה אזור גיאוגרפי בפורמט: http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. לדוגמה, הסרטונים הפופולריים ביותר ביפן הם: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. רשימה מלאה של מזהי localeID זמינה במדריך העזרה .

def PrintVideoFeed(feed):
  for entry in feed.entry:
    PrintEntryDetails(entry)

def GetAndPrintFeedByUrl:
  yt_service = gdata.youtube.service.YouTubeService()

  # You can retrieve a YouTubeVideoFeed by passing in the URI
  uri = 'http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular'
  PrintVideoFeed(yt_service.GetYouTubeVideoFeed(uri))

אחזור סרטונים שהועלו על ידי משתמש ספציפי

לכל משתמש ב-YouTube יש פיד וידאו משויך שמכיל את הסרטונים שהמשתמש העלאה, בכתובת http://gdata.youtube.com/feeds/api/users/username/uploads. הקוד הבא מדגים איך לאחזר ולהציג פיד של העלאות של משתמשים:

def GetAndPrintUserUploads(username):
  yt_service = gdata.youtube.service.YouTubeService()
  uri = 'http://gdata.youtube.com/feeds/api/users/%s/uploads' % username
  PrintVideoFeed(yt_service.GetYouTubeVideoFeed(uri))

הערה: אפשר גם להשתמש במחרוזת 'default' במקום username כדי לאחזר סרטונים של המשתמש המאומת הנוכחי.

כדי לאחזר סרטונים קשורים, מעבירים את מזהה הסרטון של האובייקט gdata.youtube.YouTubeVideoEntry לשיטה GetYouTubeRelatedVideoFeed של האובייקט gdata.youtube.service.YouTubeService. הפונקציה הזו מאחזרת אובייקט YouTubeVideoFeed שמכיל רשומות קשורות.

related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')

חיפוש סרטונים

באמצעות YouTube Data API אפשר לבקש קבוצה של רשומות שתואמות לקריטריונים מסוימים, למשל, לבקש רשומות של סרטונים שפורסמו על ידי מחבר מסוים, לפי פורמט הסרטון או שמכילות מילת מפתח מסוימת. כדי לעשות זאת, יוצרים אובייקט gdata.service.YouTubeVideoQuery עם הקריטריונים הספציפיים לחיפוש ומעבירים אותו ל-method‏ YouTubeQuery של gdata.youtube.service.YouTubeService.

הדוגמה הבאה מראה איך לבצע שאילתה לחיפוש, כאשר התוצאות ממוינות לפי מספר הצפיות, כולל סרטונים מוגבלים (שנקראים 'בוטה' ב-API):

def SearchAndPrint(search_terms):
  yt_service = gdata.youtube.service.YouTubeService()
  query = gdata.youtube.service.YouTubeVideoQuery()
  query.vq = search_terms
  query.orderby = 'viewCount'
  query.racy = 'include'
  feed = yt_service.YouTubeQuery(query)
  PrintVideoFeed(feed)

הכיתה gdata.service.Query ותתי-הכיתות שלה, כמו YouTubeVideoQuery, אחראיות ליצירת כתובות URL של פידים. ה-VideoQuery שמוצג למעלה יוצר כתובת URL שווה ערך לכתובת הבאה:

http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount

ריכזנו כאן כמה מהמאפיינים הנפוצים ביותר של YouTubeVideoQuery להגדרת פרמטרים של חיפוש:

author: הגדרת המחבר של הרשומה. 'מחבר' הוא שם נרדף לשם המשתמש ב-YouTube.
format: מציין פורמט וידאו. המערכת מקבלת פרמטרים מספריים כדי לציין אחד משני סוגים של כתובות URL לסטרימינג ב-RTSP להפעלת סרטונים בניידים, או כתובת URL מסוג HTTP לנגן Flash שניתן להטמיע.
racy: מציין אם תוכן מוגבל צריך להיכלל בתוצאות. הפונקציה מקבלת רק שני פרמטרים: 'include' או 'exclude'.
max_results: הגדרת המספר המקסימלי של רשומות להחזרה בכל פעם.
start_index: הגדרת האינדקס שמתחיל ב-1 של התוצאה הראשונה שאמורה להתאחזר (לחלוקה לדפים).
orderby: הגדרת הסדר שבו יוצגו הרשומות, למשל לפי relevance, viewCount, published או rating.
time: הגדרת פרק זמן כדי להגביל את תוצאות הפיד הרגילות ל-today,‏ this_week,‏ this_month או all_time.
vq: הגדרת מונח של שאילתת חיפוש. חיפוש המחרוזת שצוינה בכל המטא-נתונים של הסרטון, כמו שמות, תגים ותיאורים.

הערה: מידע נוסף על פרמטרים של שאילתות זמין במדריך העזרה של YouTube Data API ובמדריך העזרה של Google Data APIs.

חיפוש באמצעות קטגוריות ומילות מפתח

אתם יכולים להגביל את תוצאות החיפוש כך שיוצגו רק סרטונים שתואמים לקבוצה נתונה של קטגוריות ומילות מפתח. במדריך מוסבר איך לציין קטגוריות מוגדרות מראש ב-YouTube (כמו 'מוזיקה', 'אנשים ובלוגים' וכו') ומילות מפתח (תגים) שהוגדרו על ידי משתמשים.

הקוד הבא מדגים איך לבצע חיפוש באמצעות מילות מפתח (תגים) על ידי שינוי מונחי החיפוש לאותיות קטנות. הערה: מאחר שמילים מסוימות (כמו 'קומדיה') יכולות להיות גם קטגוריה ב-YouTube וגם מילת מפתח, בשאילתות של קטגוריות ומילות מפתח נהוג שהמילה באותיות רישיות ('קומדיה') מציינת קטגוריה ב-YouTube, והמילה באותיות קטנות ('קומדיה') מציינת מילת מפתח.

def SearchAndPrintVideosByKeywords(list_of_search_terms):
  yt_service = gdata.youtube.service.YouTubeService()
  query = gdata.youtube.service.YouTubeVideoQuery()
  query.orderby = 'viewCount'
  query.racy = 'include'
  for search_term in list_of_search_terms:
    new_term = search_term.lower()
    query.categories.append('/%s' % new_term)
  feed = yt_service.YouTubeQuery(query)
  PrintVideoFeed(feed)

חיפוש לפי תגי מפתחים

תגי מפתח למפתחים הם מילות מפתח נוספות ומוסתרות שיכולות לשמש מפתחים כדי לתייג תוכן שהועלו על ידי משתמשי קצה דרך האפליקציה שלהם. תגי המפתחות למפתחים מותאמים למפתח המפתחות למפתחים שמוגדר בכותרות במהלך ההעלאה. מילות המפתח האלה לא יהיו גלויות לציבור, ויכול להיות שנעשה בהן שימוש כדי לאחזר סרטונים. כדי לחפש סרטונים לפי תג פיתוח ספציפי, שולחים בקשת חיפוש כללית של YouTube Data API באמצעות מפתח הפיתוח. חשוב לציין את סכימה הקטגוריות ואת תג המפתח שצריכים להתאים לסרטונים. אפשר לאחזר פיד של סרטונים שתואמים לתג הפיתוח שלכם ('your_tag_here' בדוגמה שלנו) מכתובת ה-URL הבאה:

developer_tag_uri = 'http://gdata.youtube.com/feeds/videos/-/%7Bhttp%3A%2F%2Fgdata.youtube.com%2Fschemas%2F2007%2Fdevelopertags.cat%7Dyour_tag_here'
yt_service = gdata.youtube.service.YouTubeService()
PrintVideoFeed(yt_service.GetYouTubeVideoFeed(developer_tag_uri))

העלאת סרטונים

מומלץ לעיין בתרשים במדריך לפרוטוקול כדי לקבל סקירה כללית ברמה גבוהה של תהליך ההעלאה. יש שתי דרכים להעלות סרטונים:

להעלות את הסרטון ישירות מהשרתים שלכם באמצעות שיטת ההעלאה הישירה
או לשלוח קודם את המטא-נתונים, ואז לבקש מהמשתמש להעלות את הסרטון ישירות ל-YouTube באמצעות שיטת ההעלאה מבוססת-הדפדפן

העלאה ישירה

כדי להעלות סרטון, קודם צריך ליצור אובייקט gdata.youtube.YouTubeVideoEntry חדש ולהעביר לו אובייקט gdata.media.Group שמכיל את המטא-נתונים הנדרשים. בדוגמה הבאה מוצגת העלאה של סרטון Quicktime בשם 'mytestmovie.mov' ל-YouTube עם המאפיינים הבאים:

נכס	ערך
Title	סרט הבדיקה שלי
קטגוריה	מכוניות
מילות מפתח	מכוניות, מצחיקות
תיאור	התיאור שלי
Filename	mytestmovie.mov
סוג MIME של הקובץ	video/quicktime
הסרטון פרטי?	FALSE
מיקום הסרטון	37,-122 (lat,long)
תגים למפתחים	mydevelopertag, ‏ anotherdevelopertag

הקוד הבא יוצר קובץ YouTubeVideoEntry ריק להעלאה. השיטה InsertVideoEntry ב- YouTubeService דורשת את הפרמטרים הבאים:

video_entry – אובייקט gdata.youtube.VideoEntry שמכיל מטא-נתונים
filename_or_handle – אובייקט שנראה כמו קובץ או שם הקובץ שממנו הסרטון ייקרא
youtube_username — מחרוזת אופציונלית שציינו בה את שם המשתמש של החשבון שאליו רוצים להעלות את הסרטון. כמובן, צריכות להיות לחשבון שלכם את ההרשאות המתאימות. ברירת המחדל היא החשבון של המשתמש המאומת הנוכחי.
content_type — מחרוזת אופציונלית שציינו בה את סוג ה-MIME של הסרטון שרוצים להעלות.

לתשומת ליבכם, בדוגמאות האלה ההנחה היא שהמשתנה yt_service מתייחס לאובייקט YouTubeService מאומת במלואו.

# prepare a media group object to hold our video's meta-data
my_media_group = gdata.media.Group(
  title=gdata.media.Title(text='My Test Movie'),
  description=gdata.media.Description(description_type='plain',
                                      text='My description'),
  keywords=gdata.media.Keywords(text='cars, funny'),
  category=[[]gdata.media.Category(
      text='Autos',
      scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
      label='Autos')],
  player=None
)


# prepare a geo.where object to hold the geographical location
# of where the video was recorded
where = gdata.geo.Where()
where.set_location((37.0,-122.0))

# create the gdata.youtube.YouTubeVideoEntry to be uploaded
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group,
                                              geo=where)

# set the path for the video file binary
video_file_location = '/path/to/my/file.mov'

new_entry = yt_service.InsertVideoEntry(video_entry, video_file_location)

אם רצינו לתייג את הסרטון בתגי מפתח אופציונליים למפתחים (פרטים נוספים זמינים במאמר חיפוש לפי תגי מפתח למפתחים), היינו יכולים להשתמש בשיטה AddDeveloperTags לפני ביצוע הקריאה ל-InsertVideoEntry:

developer_tags = [[]'some_tag_01', 'another_tag']
video_entry.AddDeveloperTags(developer_tags)

הערה: כדי להעלות סרטונים בסטטוס 'פרטי', צריך להעביר מאפיין פרטי אל gdata.media.Group:

my_media_group = gdata.media.Group(
  title=gdata.media.Title(text='My Test Movie'),
  description=gdata.media.Description(description_type='plain',
                                      text='My description'),
  keywords=gdata.media.Keywords(text='cars, funny'),
  category=[[]gdata.media.Category(
      text='Autos',
      scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
      label='Autos')],
  player=None,
  private=gdata.media.Private()
)

video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)

# assuming that video_file_location points to a valid path
new_entry = yt_service.InsertVideoEntry(video_entry, video_file_location)

העלאה מבוססת-דפדפן

ההעלאה מבוססת-הדפדפן מתבצעת כמעט באופן זהה להעלאה ישירה, חוץ מזה שלא מעלים את הקובץ הבינארי באותה בקשה שבה משתמשים כדי לשלוח את המטא-נתונים של הסרטון. במקום זאת, פשוט יוצרים קובץ YouTubeVideoEntry שמכיל מטא-נתונים בלבד. לאחר מכן, הרשומה של הסרטון מתפרסמת בקישור מיוחד בשרת של YouTube API. תגובת ה-XML מכילה token ו-url, שאפשר להשתמש בהם כדי להעלות את הקובץ הבינארי באמצעות טופס HTML רגיל.

# create media group as usual
my_media_group = gdata.media.Group(
  title=gdata.media.Title(text='My Test Movie'),
  description=gdata.media.Description(description_type='plain',
                                      text='My description'),
  keywords=gdata.media.Keywords(text='cars, funny'),
  category=[[]gdata.media.Category(
      text='Autos',
      scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
      label='Autos')],
  player=None
)

# create video entry as usual
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)

# upload meta data only
response = yt_service.GetFormUploadToken(video_entry)

# parse response tuple and use the variables to build a form (see next code snippet)
post_url = response[[]0]
youtube_token = response[[]1]

הקוד שלמעלה מדפיס קישור ואסימון שמשמשים ליצירת טופס HTML להצגה בדפדפן של המשתמש. טופס לדוגמה פשוט מוצג בהמשך, כאשר youtube_token מייצג את התוכן של רכיב האסימון שהוחזר, כפי שמוצג באחזור מ-YouTubeVideoEntry למעלה. כדי שהמשתמש יועבר לאתר שלכם אחרי שליחת הטופס, חשוב לצרף פרמטר next ל-post_url (כפי שמוצג בהמשך). הפרמטר הזה יפעל באותו אופן שבו פועל הפרמטר next בקישור AuthSub. ההבדל היחיד הוא שבמקום אסימון לשימוש יחיד, כאן מוחזרים המשתנה status והמשתנה id כפרמטרים של כתובת URL.

next = 'http://example.com/post_video_upload.pyc'

form = """<form action="%s?nexturl=%s" method="post" enctype="multipart/form-data">
          <input name="file" type="file"/>
          <input name="token" type="hidden" value="%s"/>
          <input value="Upload Video File" type="submit" />
          </form>""" % (post_url, next, youtube_token)

התגובה להעלאה מוצלחת תיראה כך:

http://example.com/post_video_upload.pyc?status=200&id=ABC123

הפרמטר status מחזיר את סטטוס העסקה ב-HTTP של עסקת ההעלאה. הפרמטר id מחזיר את מזהה הווידאו ב-YouTube שהוקצה לסרטון שהועלה.

בדיקת סטטוס ההעלאה

אחרי העלאת סרטון, הוא יופיע באופן מיידי בפיד ההעלאות של משתמש מאומת. עם זאת, הוא לא יהיה גלוי לכולם באתר עד שהוא יטופל. גם סרטונים שנדחו או שלא הצלחת להעלות אותם יופיעו בפיד ההעלאות של המשתמש המאומת בלבד. הקוד הבא בודק את הסטטוס של YouTubeVideoEntry כדי לראות אם הוא עדיין לא פעיל או אם הוא נדחה.

upload_status = yt_service.CheckUploadStatus(new_entry)

if upload_status is not None:
  video_upload_state = upload_status[[]0]
  detailed_message = upload_status[[]1]

עדכון ומחיקה של סרטונים

עדכון פרטי הסרטון

כדי לעדכן את המטא-נתונים של הסרטון, פשוט מעדכנים את האובייקט YouTubeVideoEntry ואז משתמשים בשיטה UpdateVideoEntry של האובייקטים YouTubeService. השיטה הזו מקבלת פרמטר YouTubeVideoEntry שמכיל מטא-נתונים מעודכנים.

# assuming we have a video entry that was just posted in our 'new_entry' variable
new_entry.media.title.text = 'My Updated Video Title'
new_entry.media.description.text = 'Just updated'

updated_entry = yt_service.UpdateVideoEntry(new_entry)

מחיקת סרטון

מחיקת סרטון היא פשוטה מאוד, והיא כוללת רק קריאה ל-DeleteVideoEntry של האובייקט YouTubeService.

response = yt_service.DeleteVideoEntry(entry_to_be_deleted)

if response:
  print 'Video successfully deleted!'

שימוש בתכונות הקהילה

הוספת דירוג

כדי לדרג סרטון, משתמשים ב-method‏ AddRating של האובייקט YouTubeService. לתשומת ליבכם, אי אפשר לדרג סרטונים שלכם, והסרטונים צריכים לקבל דירוג בין 1 ל-5 (כולל):

video_id_to_rate = 'Ncakifd_16k'
video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id_to_rate)
response = yt_service.AddRating(3, video_entry)

תגובות

אחזור תגובות לסרטון

אם יש לכם אובייקט YouTubeVideoEntry או מזהה וידאו פשוט, אתם יכולים לאחזר ולהדפיס פיד שמכיל את התגובות לסרטון באמצעות השיטה GetYouTubeVideoCommentFeed של האובייקט YouTubeService. הפיד שנוצר הוא gdata.youtube.YouTubeCommentFeed, שמורכב מאובייקטים מסוג gdata.youtube.YouTubeCommentEntry. אפשר לנתח את הפיד כמו כל פיד אחר:

video_id = 'ABC123...'
comment_feed = yt_service.GetYouTubeVideoCommentFeed(video_id=video_id)

for comment_entry in comment_feed.entry:
  print comment_entry.ToString()

הוספת תגובה

כדי להוסיף תגובה חדשה, פשוט משתמשים ב-method‏ AddComment של האובייקט YouTubeService. השיטה דורשת אובייקט YouTubeVideoEntry מלא שעליו רוצים להוסיף תגובה, וכן מחרוזת שמייצגת את התגובה:

my_comment = 'what a boring test video'
video_id = '9g6buYJTt_g'
video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id)
yt_service.AddComment(comment_text=my_comment, video_entry=video_entry)

סרטוני תגובה

סרטון תגובה ב-YouTube היה סרטון ששויך, בתור תשובה, לסרטון שני. התכונה 'תגובות בסרטון' הוצאה משימוש, כפי שמוסבר בהודעה הזו. סרטוני התשובה הקיימים עדיין זמינים, אבל ב-YouTube כבר אין אפשרות לאחזר רשימה של סרטוני התשובה לסרטון מסוים, להעלות סרטוני תגובה חדשים או למחוק סרטוני תגובה. עם זאת, עדיין אפשר למחוק את הסרטון ששימש בסרטון התגובה. כתוצאה מכך, הפונקציות האלה כבר לא נתמכות ב-API.

בקשות API לפעולות של תגובות בסרטונים מחזירות עכשיו את הפרטים הבאים:

בקשה לאחזור תגובות לסרטון תחזיר רשימה ריקה.
בקשה להוספת תגובה בסרטון מחזירה את קוד התגובה HTTP 403.
בקשה למחיקת תגובה בסרטון מחזירה את קוד התגובה HTTP 403.

סימון סרטון

כדי להוסיף תלונה על סרטון, משתמשים בשיטה AddComplaint באובייקט YouTubeService. מונח התלונה חייב להיות קטגוריה חוקית. מידע נוסף זמין בקטע הוספת תלונה במדריך לפרוטוקול.

video_id_to_flag = 'Ncakifd_16k'
complaint_term = 'VIOLENCE'
complaint_text = ('Please ignore this complaint. '
                  'I\'m testing a YouTube API and needed to issue '
                  'a complaint to test the add complaint function. ')

response = yt_service.AddComplaint(complaint_text, complaint_term, video_id_to_flag)

שמירה ואיסוף של סרטונים

סרטונים מועדפים

אחזור הסרטונים המועדפים של משתמש

משתמשי YouTube יכולים לסמן סרטונים שהם צופים בהם כ'מועדפים'. המיקום הכללי של הפיד המועדף של המשתמש הוא כתובת ה-URL הבאה.

http://gdata.youtube.com/feeds/api/users/username/favorites

כדי לאחזר את הסרטונים האהובים של משתמש, משתמשים בשיטה GetUserFavoritesFeed של האובייקט YouTubeService. השיטה מקבלת מחרוזת אופציונלית כפרמטר שמייצג את שם המשתמש ב-YouTube של המשתמש שרוצים לאחזר את הפיד המועדף שלו.

favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')

הפיד המוחזר הוא פיד וידאו רגיל שמכיל אובייקטים מסוג YouTubeVideoEntry.

הערה: לחלופין, אפשר להעביר את המחרוזת default כדי לאחזר את המועדפים של המשתמש המאומת הנוכחי. זוהי התנהגות ברירת המחדל של השיטה GetUserFavoritesFeed אם לא צוין שם משתמש.

הוספה של מיקום מועדף

כדי להוסיף סרטון מועדף, משתמשים ב-method ‏AddVideoEntryToFavorites של האובייקט YouTubeService. הפרמטרים הם YouTubeVideoEntry שרוצים להוסיף, ואפשר גם לציין את שם המשתמש שאליו רוצים להוסיף את ה-favorite (ברירת המחדל היא המשתמש המאומת הנוכחי).

video_id = 'Ncakifd_16k'
video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id)
response = yt_service.AddVideoEntryToFavorites(video_entry)

# The response, if successfully posted is a YouTubeVideoEntry
if isinstance(response, gdata.youtube.YouTubeVideoEntry):
  print 'Video successfully added to favorites'

מחיקה של מיקום מועדף

כדי למחוק מועדף, פשוט משתמשים בשיטה DeleteVideoEntryFromFavorites של האובייקט YouTubeService.

video_id = 'Ncakifd_16k'
response = yt_service.DeleteVideoEntryFromFavorites(video_id)
if response is True:
  print 'Video deleted from favorites'

פלייליסטים

לכל משתמש ב-YouTube יש פיד פלייליסטים שמכיל את כל הפלייליסטים שהמשתמש יצר. לכל פלייליסט יהיה פיד של כל הסרטונים שבו.

אחזור פלייליסטים של משתמשים

כדי לאחזר באופן ידני רשימה של כל הפלייליסטים של משתמש, משתמשים בכתובת ה-URL הבאה:

http://gdata.youtube.com/feeds/api/users/username/playlists

באמצעות ספריית הלקוח של Python, אפשר להשתמש בשיטה GetYouTubePlaylistFeed של האובייקט YouTubeService:

playlist_feed = yt_service.GetYouTubePlaylistFeed(username='gdpython')

# instead of passing in a username, you can also pass the URI to the playlist feed:
playlist_feed = yt_service.GetYouTubePlaylistFeed(uri='http://gdata.youtube.com/feeds/api/users/default/playlists')

הערה: במקום להעביר שם משתמש ספציפי (למשל 'gdpython' בדוגמה שלמעלה), אפשר גם להעביר את המחרוזת 'default' כדי להפנות למשתמש המאומת הנוכחי.

gdata.youtube.YouTubePlaylistFeed מייצג פיד של אובייקטים מסוג gdata.youtube.YouTubePlaylistEntry. אלה הפלייליסטים הספציפיים של המשתמש. רשומות של סרטונים בפלייליסט מסוים מיוצגות כאובייקטים מסוג gdata.youtube.YouTubePlaylistVideoEntry. האובייקטים האלה דומים מאוד לאובייקטים רגילים מסוג gdata.youtube.YouTubeVideoEntry, מלבד כמה יוצאים מן הכלל. אפשר להחיל על הסרטונים שמות ותיאורים בהתאמה אישית, ושדה מיקום מציין איפה הסרטון מופיע בפלייליסט.

אחזור פרטי הפלייליסט

אם נתון YouTubePlaylistEntry (שמייצג פלייליסט ספציפי), אפשר לקבל YouTubePlaylistVideoFeed שמכיל אובייקטים מסוג YouTubePlaylistVideoEntry. כפי שהוסבר למעלה, האובייקטים האלה מייצגים סרטונים ספציפיים בפלייליסט (עם שמות ותיאורים מותאמים אישית, אם יש כאלה). כדי לקבל את הפיד הזה, מעבירים את ה-URI של הפלייליסט לשיטה GetYouTubePlaylistVideoFeed של האובייקט YouTubeService:

# a typical playlist URI
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'

playlist_video_feed = yt_service.GetYouTubePlaylistVideoFeed(uri=playlist_uri)

# iterate through the feed as you would with any other
for playlist_video_entry in playlist_video_feed.entry:
  print playlist_video_entry.title.text

הוספת פלייליסט

כדי להוסיף פלייליסט חדש, פשוט משתמשים בשיטה AddPlaylist של האובייקט YouTubeService. לשיטה הזו יש את הפרמטרים הבאים: playlist_title, ‏ playlist_description (שתי מחרוזות) ומשתנה בוליאני אופציונלי שאפשר להגדיר כ-True אם רוצים לסמן את הפלייליסט כפרטי.

new_public_playlistentry = yt_service.AddPlaylist('my new playlist', 'a new playlist')

if isinstance(new_public_playlistentry, gdata.youtube.YouTubePlaylistEntry):
  print 'New playlist added'

# adding a private playlist
new_private_playlistentry = yt_service.AddPlaylist('new private playlist', 'a new private playlist', True)

if isinstance(new_private_playlistentry, gdata.youtube.YouTubePlaylistEntry):
  print 'New private playlist added'

עדכון פלייליסט

כדי לעדכן פלייליסט, משתמשים בשיטה UpdatePlaylist של האובייקט YouTubeService. לשיטה יש את הפרמטרים הבאים: המזהה של הפלייליסט שרוצים לעדכן, שם חדש, תיאור חדש, ערך בוליאני אופציונלי לסימון הפלייליסט כפרטי ומחרוזת אופציונלית שמציינת את שם המשתמש שבבעלותו הפלייליסט. כברירת מחדל, המחרוזת תהיה של המשתמש המאומת הנוכחי.

# here we are updating a public playlist with a new title while also making it private

# we assume that playlist_to_be_updated here represents a YouTubePlaylistEntry object
playlist_entry_id = playlist_to_be_updated.id.text.split('/')[[]-1]

# we want to keep the original description for the playlist so we store it first
original_description = playlist_to_be_updated.description.text

updated_playlist = yt_service.UpdatePlaylist(playlist_entry_id,
                                             'a new updated title',
                                             original_playlist_description,
                                             playlist_private=True)

הוסף סרטון לפלייליסט

אפשר להוסיף סרטון לפלייליסט באמצעות השיטה AddPlaylistVideoEntryToPlaylist של האובייקט YouTubeService. הקוד הבא מוסיף סרטון לפלייליסט, עם שם ותיאור מותאמים אישית.

custom_video_title = 'my test video on my test playlist'
custom_video_description = 'this is a test video on my test playlist'
video_id = 'Ncakifd_16k'
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'

playlist_video_entry = yt_service.AddPlaylistVideoEntryToPlaylist(
    playlist_uri, video_id, custom_video_title, custom_video_description)

if isinstance(playlist_video_entry, gdata.youtube.YouTubePlaylistVideoEntry):
  print 'Video added'

הערה: חשוב לדעת שאין צורך בכותרת ובתיאור מותאמים אישית, ואם לא מציינים אותם, המערכת תשתמש בכותרת ובתיאור בפועל של הסרטון.

עריכת פרטי הסרטון בפלייליסט

משתמשים בשיטה UpdatePlaylistVideoEntryMetaData של האובייקט YouTubeService כדי לשנות את המטא-נתונים של YouTubePlaylistVideoEntry. בדוגמה הבאה, החלטנו לתת לסרטון שם מותאם אישית חדש ולהעביר אותו למיקום הראשון (מיקום 1) בפלייליסט.

playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'

new_video_title = 'a useful video'
new_video_description = 'updated video description'

updated_playlist_video_entry = yt_service.UpdatePlaylistVideoEntryMetaData(
    playlist_uri, playlist_entry_id, new_video_title, new_video_description, 1)

הערה: אם רוצים להחזיר את התיאור והשם של סרטון בפלייליסט למטא-נתונים המקוריים, פשוט מעבירים את הערך NULL גם לשם וגם לתיאור.

הסרת הסרטון מהפלייליסט

כדי להסיר סרטון מפלייליסט, משתמשים בשיטה DeletePlaylistVideoEntry של האובייקט YouTubeService. לשיטה נדרשים מזהה ה-URI של הפלייליסט שמכיל את הרשומה שרוצים למחוק, וגם המזהה של הרשומה:

playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'
response = yt_service.DeletePlaylistVideoEntry(playlist_uri,
                                               playlist_entry_id)
if response is True:
  print 'Entry successfully deleted'

מחיקת פלייליסט

כדי למחוק פלייליסט, פשוט משתמשים בשיטה DeletePlaylist של האובייקט YouTubeService, ומעבירים את ה-URI של הפלייליסט שרוצים למחוק:

playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
response = yt_service.DeletePlaylist(playlist_uri)

if response is True:
  print 'Playlist successfully deleted'

מינויים

כדי לאחזר רשימה של הערוצים, החיפושים והפריטים המועדפים שהמשתמש מסוים מנוי אליהם, משתמשים ב-URI הבא:

http://gdata.youtube.com/feeds/api/users/username/subscriptions

הערה: לחלופין, אפשר להעביר את המחרוזת default כדי לאחזר את המועדפים של המשתמש המאומת הנוכחי.

אחזור המינויים של המשתמשים

הקוד הבא מראה איך לאחזר ולהדפיס את רשימת המינויים של משתמש נתון. מינויים מיוצגים כ-gdata.youtube.YouTubeSubscriptionFeed שמכיל אובייקטים מסוג gdata.youtube.YouTubeSubscriptionEntry. כדי לאחזר מינויים, משתמשים בשיטה GetYouTubeSubscriptionFeed של האובייקט YouTubeService, ומעבירים את ה-URI של פיד המינוי או את שם המשתמש שרוצים לאחזר את פיד המינוי שלו. ברירת המחדל של הפרמטר username היא המשתמש המאומת הנוכחי.

subscription_feed = yt_service.GetYouTubeSubscriptionFeed(username='gdpython')

if isinstance(subscription_feed, gdata.youtube.YouTubeSubscriptionFeed)):
  # given a YouTubeSubscriptionEntry we can determine it's type (channel, favorite, or query)
  for entry in subscription_feed.entry:
    print entry.GetSubscriptionType()

הוספת מינוי

כדי ליצור מינוי חדש, צריך להוסיף YouTubeSubsciptionEntry חדש לפיד המינויים של המשתמש המאומת. אפשר ליצור שלושה סוגים של מינויים: מינוי לערוץ של משתמש (באמצעות AddSubscriptionToChannel), מינוי למועדון המועדפים של משתמש (באמצעות AddSubscriptionToFavorites) או מינוי למילת מפתח ספציפית (באמצעות AddSubscriptionToQuery). הקוד הבא מצרף את המשתמש המאומת למינוי לערוץ 'GoogleDevelopers'.

new_subscription = yt_service.AddSubscriptionToChannel(
      username_to_subscribe_to='GoogleDevelopers')

if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
  print 'New subscription added'

אפשר גם להירשם לעדכונים על המועדפים של המשתמש 'GoogleDevelopers':

new_subscription = yt_service.AddSubscriptionToFavorites(
    username='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
  print 'New subscription added'

לבסוף, אפשר גם להירשם למונחי חיפוש ספציפיים. כאן אנחנו נרשמים לשאילתה לגבי סרטונים שמתויגים בתג 'python'.

new_subscription = yt_service.AddSubscriptionToQuery(query='python')

if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
  print 'New subscription added'

מחיקת מינוי

כדי למחוק מינוי של משתמש, משתמשים ב-method‏ DeleteSubscription של האובייקט YouTubeService.

sample_subscription_uri = ('http://gdata.youtube.com/feeds/api/users/'
                           'gdpython/subscriptions/c0c77ca6102a7479')

response = yt_service.DeleteSubscription(sample_subscription_uri)

if response is True:
  print 'Subscription successfully deleted'

הפעלת אינטראקציה של משתמשים

פרופילים של משמש

אחזור פרופיל של משתמש

כדי לאחזר ידנית את פרופיל YouTube של משתמש, משתמשים ב-URI הבא:

http://gdata.youtube.com/feeds/api/users/username

אפשר לאחזר gdata.youtube.YouTubeUserEntry באמצעות השיטה GetYouTubeUserEntry של האובייקט YouTubeService.

user_entry = yt_service.GetYouTubeUserEntry(username='gdpython')

# we can then write a helper function to print out the user details
def PrintUserEntry(entry):
  # print required fields where we know there will be information
  print 'URI: %s\n' % entry.id.text
  print 'Age: %s\n' % entry.age.text
  print 'Gender: %s\n' % entry.gender.text
  print 'Location: %s\n' % entry.location.text

  # check if there is information in the other fields and if so print it
  if user.first_name: 
    print 'First Name: %s\n' % user.first_name.text
  if user.last_name:
    print 'Last Name: %s\n' % user.last_name.text
  if user.relationship:
    print 'Relationship: %s\n' % user.relationship.text
  if user.description:
    print 'About me: %s\n' % user.description.text
  for link in user.link:
    if link.rel == 'related':
      print 'Website: %s\n' % link.href
  if user.company:
    print 'Company: %s\n' % user.company.text
  if user.occupation:
    print 'Occupation: %s\n' % user.occupation.text
  if user.school:
    print 'School: %s\n' % user.school.text
  if user.hobbies:
    print 'Hobbies: %s\n' % user.hobbies.text
  if user.movies:
    print 'Movies: %s\n' % user.movies.text
  if user.music:
    print 'Music: %s\n' % user.music.text
  if user.books:
    print 'Books: %s\n' % user.books.text
  if user.hometown:
    print 'Hometown: %s\n' % user.hometown.text

אנשי קשר

אפשר לאחזר את רשימת אנשי הקשר של משתמש נתון מכתובת ה-URL הבאה:

http://gdata.youtube.com/feeds/api/users/username/contacts

אחזור אנשי הקשר של המשתמש

אפשר להשתמש ב-method GetYouTubeContactFeed של האובייקט YouTubeService כדי לאחזר gdata.youtube.YouTubeContactFeed, שמכיל אובייקטים מסוג gdata.youtube.YouTubeContactEntry.

contact_feed = yt_service.GetYouTubeContactFeed(username='GoogleDevelopers')
for entry in contact_feed.entry:
  print entry.title.text
  # find the apprpriate category element to find out the contact type
  for category in entry.category:
    if category.scheme == 'http://gdata.youtube.com/schemas/2007/contact.cat':
      print category.term

הוספת איש קשר

כדי להוסיף איש קשר חדש לפיד של אנשי הקשר של משתמש, משתמשים בשיטה AddContact של האובייקט YouTubeService.

new_contact = yt_service.AddContact(contact_username='GoogleDevelopers')

if isinstance(new_contact, gdata.youtube.YouTubeContactEntry)
  print 'New contact added'

אישור או דחייה של איש קשר

כדי לעדכן איש קשר, משתמשים בשיטה UpdateContact של האובייקט YouTubeService. אפשר להשתמש בשיטה הזו כדי לאשר או לדחות בקשות ליצירת קשר, וגם כדי לסווג את אנשי הקשר בתור 'חברים' או 'משפחה'. בדוגמה הבאה אנחנו מאשרים איש קשר, ואז מגדירים את הקטגוריה שלו כ 'משפחה':

# in this case user 'gdpython' has requested to be our contact
#so the original contact status is 'pending'
updated_contact = yt_service.UpdateContact('gdpython', 'accepted', 'Family')

if isinstance(updated_contact, gdata.youtube.YouTubeContactEntry)
  print 'New contact added'

מחיקת איש קשר

כדי למחוק איש קשר, משתמשים בשיטה DeleteContact של האובייקט YouTubeService, ומעבירים את שם המשתמש של איש הקשר שרוצים למחוק.

response = yt_service.DeleteContact(contact_username='gdpython')

if response is True:
  print 'Contact deleted'

חזרה למעלה

מדריך למפתחים: Python קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.