def get_credentials(*, scopes): """Gets valid user credentials from storage. If nothing has been stored, or if the stored credentials are invalid, the OAuth2 flow is completed to obtain the new credentials. Returns: Credentials, the obtained credential. """ credential_dir = os.path.join(HOME_DIR, '.cache', __package__, 'credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'googleapis.json') store = Storage(credential_path) credentials = store.get() # see https://developers.google.com/api-client-library/python/auth/web-app # kw: "incremental scopes" if not credentials or credentials.invalid or not credentials.has_scopes(scopes): flow = client.flow_from_clientsecrets(GOOGLE_SECRETS, scopes) flow.user_agent = 'Bonobo ETL (https://www.bonobo-project.org/)' flags = argparser.parse_args(['--noauth_local_webserver']) credentials = tools.run_flow(flow, store, flags) print('Storing credentials to ' + credential_path) return credentials
def upload_video(self, files, title="video", description="description", category="22", keywords="", privacy="public"): argparser.add_argument("--file") argparser.add_argument("--title") argparser.add_argument("--description") argparser.add_argument("--category") argparser.add_argument("--keywords") argparser.add_argument("--privacyStatus", choices=self.VALID_PRIVACY_STATUSES) arguments = ["--file=" + files, "--title=" + title, "--description=" + description, "--category=" + category, "--keywords=" + keywords, "--privacyStatus=" + privacy] args = argparser.parse_args(arguments) if not os.path.exists(args.file): exit("Error finding video file exiting...") tempyou = self.get_authenticated_service(args) videoid = None try: videoid = self.initialize_upload(tempyou, args) print "Done uploading... Success!" except HttpError, error: print "A connection error (%d) occured: %s " % (error.resp.status, error.content) exit("Error uploading.....")
def upload_video(title, video_path, caption_path, keywords, description, thumbnail, public=False): if public: priv_status = "public" else: priv_status = "private" args = argparser.parse_args([ "--file", video_path, "--caption", caption_path, "--title", title, "--description", description, "--keywords", ",".join(keywords), "--thumbnail", thumbnail, "--privacyStatus", priv_status ]) if not os.path.exists(args.file): exit("Please specify a valid file using the --file= parameter.") youtube = get_authenticated_service(args) try: initialize_upload(youtube, args) except HttpError as e: print(("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)))
def __init__(self, secrets_file="client_secrets.json"): self.service = None httplib2.RETRIES = 1 self.MAX_RETRIES = 10 self.RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected, httplib.IncompleteRead, httplib.ImproperConnectionState, httplib.CannotSendRequest, httplib.CannotSendHeader, httplib.ResponseNotReady, httplib.BadStatusLine) self.RETRIABLE_STATUS_CODES = [500, 502, 503, 504] self.CLIENT_SECRETS_FILE = secrets_file self.scope = "https://www.googleapis.com/auth/youtube" self.YOUTUBE_API_SERVICE_NAME = "youtube" self.YOUTUBE_API_VERSION = "v3" self.MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the Developers Console https://console.developers.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), self.CLIENT_SECRETS_FILE)) self.VALID_PRIVACY_STATUSES = ("public", "private", "unlisted") self.__get_authenticated_service(argparser.parse_args([], None))
def authentication(self, storage): return run_flow( OAuth2WebServerFlow( client_id=self.google_client_id, client_secret=self.google_client_secret, scope=['https://www.googleapis.com/auth/gmail.modify']), storage, argparser.parse_args([]))
def authenService(): CLIENT_SECRETS_FILE = "client_secrets.json" #display following message if file not found MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the Developers Console https://console.developers.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,message=MISSING_CLIENT_SECRETS_MESSAGE,scope=YOUTUBE_READ_WRITE_SCOPE) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args() credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,http=credentials.authorize(httplib2.Http())) return youtube
def ping_youtube(self, *args, **kwargs): '''pings youtube for number of subscribers on a given channel ID''' #Youtube API V3 authentication #External modules and dependencies are required try: argparser.add_argument("--message", required=False, help="Text of message to post.") args = argparser.parse_args() youtube = get_authenticated_service(args) #headers = ['youtube_id', 'video_id'] #Get statistics from channel id for i,ID in enumerate(self.data_dict['youtube_channel_id']): subs = youtube.channels().list(part="statistics", id=ID).execute() if subs['items']: #print 'No. of subscribers:',subs['items'][0]['statistics']['subscriberCount'] self.data_dict['subscribers '+self.stamp].append(subs['items'][0]['statistics']['subscriberCount']) else: #print 'No youtube subscribers found' self.data_dict['subscribers '+self.stamp].append('-') #Get video views for given id for i,ID in enumerate(self.data_dict['video_id']): video = youtube.videos().list(part="statistics", id=ID).execute() if video['items']: #print 'No. of video views:',video['items'][0]['statistics']['viewCount'] self.data_dict['video views '+self.stamp].append(video['items'][0]['statistics']['viewCount']) else: #print 'No youtube video was found' self.data_dict['video views '+self.stamp].append('-') except Exception, error: self.log_error('youtube')
def subscriber_views(): now = datetime.now() start = (now - timedelta(days=30)).strftime("%Y-%m-%d") end = (now - timedelta(days=1)).strftime("%Y-%m-%d") argparser.add_argument("--metrics", help="Report metrics", default="views,averageViewDuration,averageViewPercentage") argparser.add_argument("--dimensions", help="Report dimensions", default="day,subscribedStatus") argparser.add_argument("--start-date", default=start, help="Start date, in YYYY-MM-DD format") argparser.add_argument("--end-date", default=end, help="End date, in YYYY-MM-DD format") argparser.add_argument("--max-results", help="Max results", default=90) argparser.add_argument("--sort", help="Sort order", default="-day") args = argparser.parse_args() (youtube, youtube_analytics) = get_authenticated_services(args) try: channel_id = get_channel_id(youtube) analytics_results, headers = run_analytics_report(youtube_analytics, channel_id, args) df_total_views = pd.DataFrame(analytics_results,columns=["date","subscribedStatus","views","averageViewDuration","averageViewPercentage"]) # df_total_views.loc[:,"netSubscribers"] = df_total_views["subscribersGained"] - df_total_views["subscribersLost"] # df_total_views.loc[:,"totalWatchTime"] = df_total_views["views"]*df_total_views["averageViewDuration"] df_total_views.set_index("date",inplace=True) # df_total_views.to_csv("Youtube Subscribed vs Not Subscribed.csv") return df_total_views except HttpError, e: print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)
def __enter__(self): # Ensure that we have not re-entered if self.temp_path != None or self.service != None: raise Exception('Cannot use multiple nested with blocks on same Youtube object!') flow = flow_from_clientsecrets( self.client_secrets_path, scope=YOUTUBE_UPLOAD_SCOPE, message=MISSING_CLIENT_SECRETS_MESSAGE) temp_file = NamedTemporaryFile(delete=False) self.temp_path = temp_file.name temp_file.close() storage = Storage(self.temp_path) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run_flow( flow, storage, argparser.parse_args(list()) ) self.service = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) return self
def setup(): query = raw_input("Enter your query: ") argparser.add_argument("--q", help="Search term", default=query) #change the default to the search term you want to search argparser.add_argument("--max-results", help="Max results", default=50) #default number of results which are returned. It can vary from 0 - 100 options = argparser.parse_args() page_tokens = {} responses = [] search_response = youtube.search().list( # Call the search.list method to retrieve results matching the specified query term. q=options.q, type="video", part="id,snippet", maxResults=options.max_results ).execute() responses.append(search_response) for i in range(0,4): page_tokens['p' + str(i)] = (search_response['nextPageToken']) search_response = youtube.search().list( # Call the search.list method to retrieve results matching the specified query term. q=options.q, type="video", part="id,snippet", maxResults=options.max_results, pageToken = page_tokens['p' + str(i)] ).execute() responses.append(search_response) print json.dumps(responses, indent=4, sort_keys=True)
def main(): now = datetime.now() one_day_ago = (now - timedelta(days=1)).strftime("%Y-%m-%d") one_week_ago = (now - timedelta(days=7)).strftime("%Y-%m-%d") argparser.add_argument("--channel_id", help="Channel ID", required=True) argparser.add_argument("--content_owner_id", help="Content Owner Id", required=True) argparser.add_argument("--metrics", help="Report metrics", default="views,comments,favoritesAdded,favoritesRemoved,likes,dislikes,shares") argparser.add_argument("--dimensions", help="Report dimensions", default="video") argparser.add_argument("--start-date", default=one_week_ago, help="Start date, in YYYY-MM-DD format") argparser.add_argument("--end-date", default=one_day_ago, help="End date, in YYYY-MM-DD format") argparser.add_argument("--max-results", help="Max results", default=10) argparser.add_argument("--sort", help="Sort order", default="-views") args = argparser.parse_args() youtube_analytics = get_authenticated_services(args) try: run_analytics_report(youtube_analytics, args) except HttpError, e: print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)
def ListPlaylist(): CLIENT_SECRETS_FILE = "../client_secrets.json" CLIENT_SECRETS_FILE = os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE) # This variable defines a message to display if the CLIENT_SECRETS_FILE is # missing. MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the Developers Console https://console.developers.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account. YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, message=MISSING_CLIENT_SECRETS_MESSAGE, scope=YOUTUBE_READ_WRITE_SCOPE, redirect_uri="http://youtube.com",) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: ##flags = argparser.parse_args() flags = argparser.parse_args(args=[]) credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) # This code creates a new, private playlist in the authorized user's channel. list_playlists_response = youtube.playlists().list( part="id, snippet", mine=True, maxResults=50 ).execute() data = [] for item in list_playlists_response.get("items", []): print "title: %s (id: %s)" % (item["snippet"]["title"], item["id"]) data.append([item["snippet"]["title"].encode(), item["id"].encode()]) return data
def setup(): '''Attempt to setup a nice youtube objeect''' # do not actually parse arguments args = argparser.parse_args(args=[]) args.noauth_local_webserver=True youtube = get_authenticated_service(args) return youtube
def retrieve_credentials(self): storage = Storage(self.storage_path) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run_flow(self.create_oauth_flow(), storage, argparser.parse_args([]), http=self.http) return credentials
def setup_args(): argparser.add_argument("--videoid", help="Required; ID for video.") argparser.add_argument("--debug", help="Prints all video comments read.", action="store_true") argparser.add_argument("--showreason", help="Prints comment that classifies video as weird.", action="store_true") args = argparser.parse_args() if not args.videoid: exit("Please specify videoid using the --videoid= parameter.") return args
def main(): client_id = sys.argv[1] client_secret = sys.argv[2] scope = sys.argv[3] flow = OAuth2WebServerFlow(client_id, client_secret, scope) storage = Storage('google.json') flags = argparser.parse_args([]) run_flow(flow, storage, flags)
def render(self, search_args): argparser.add_argument("--q", help="Search term", default=search_args) argparser.add_argument("--max-results", help="Max results", default=25) argparser.add_argument("--type", help="Type of result", default="video") args = argparser.parse_args() try: self.__youtube_search(args) except HttpError as e: print ("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content))
def search_by_word(self, search_term): args = argparser.parse_args() args.q = search_term try: return self.youtube_search(args) except HttpError as e: print("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)) return ''
def add_song(playlistId, videoId): CLIENT_SECRETS_FILE = "../client_secrets.json" CLIENT_SECRETS_FILE = os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE) # This variable defines a message to display if the CLIENT_SECRETS_FILE is # missing. MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the Developers Console https://console.developers.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account. YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, message=MISSING_CLIENT_SECRETS_MESSAGE, scope=YOUTUBE_READ_WRITE_SCOPE, redirect_uri="http://youtube.com",) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: ##flags = argparser.parse_args() flags = argparser.parse_args(args=[]) credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) playlistitems_list_request = youtube.playlistItems().insert( part="snippet", body={ "snippet": { "playlistId":playlistId, "resourceId": {"kind":"youtube#video", "videoId":videoId} } } ).execute() return "okkkkkkkkkkkkkkkkkkkkkk"
def getAllVideosFromChannel(): flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, message=MISSING_CLIENT_SECRETS_MESSAGE, scope=YOUTUBE_READONLY_SCOPE) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args() credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) # Retrieve the contentDetails part of the channel resource for the # authenticated user's channel. channels_response = youtube.channels().list( mine=True, part="contentDetails" ).execute() for channel in channels_response["items"]: # From the API response, extract the playlist ID that identifies the list # of videos uploaded to the authenticated user's channel. uploads_list_id = channel["contentDetails"]["relatedPlaylists"]["uploads"] if __debug__: print "Videos in list %s" % uploads_list_id # Retrieve the list of videos uploaded to the authenticated user's channel. playlistitems_list_request = youtube.playlistItems().list( playlistId=uploads_list_id, part="snippet", maxResults=50 ) result = dict() while playlistitems_list_request: playlistitems_list_response = playlistitems_list_request.execute() # Print information about each video. for playlist_item in playlistitems_list_response["items"]: title = playlist_item["snippet"]["title"] video_id = playlist_item["snippet"]["resourceId"]["videoId"] if __debug__: print "%s (%s)" % (title, video_id) result[title] = video_id playlistitems_list_request = youtube.playlistItems().list_next( playlistitems_list_request, playlistitems_list_response) if __debug__: print return result
def get_gdata_credentials(secrets, creds, scope, force=False): storage = Storage(creds) credentials = storage.get() if credentials is None or credentials.invalid or force: credentials = run_flow(flow_from_clientsecrets(secrets, scope=scope), storage, argparser.parse_args([])) if credentials.access_token_expired: credentials.refresh(httplib2.Http()) return credentials
def scrapingInYoutube(text): #sudo pip install --upgrade google-api-python-client # Set DEVELOPER_KEY to the API key value from the APIs & auth > Registered apps # tab of # https://cloud.google.com/console # Please ensure that you have enabled the YouTube Data API for your project. DEVELOPER_KEY = "AIzaSyAcmrNRK5GBEmlUWTFidyqj08m3572jUG8" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" def youtube_search(options, keyword): youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, developerKey=DEVELOPER_KEY) # Call the search.list method to retrieve results matching the specified # query term. options.q=keyword search_response = youtube.search().list( q=options.q, part="id,snippet", maxResults=options.max_results ).execute() videos = [] channels = [] playlists = [] # Add each result to the appropriate list, and then display the lists of # matching videos, channels, and playlists. for search_result in search_response.get("items", []): if search_result["id"]["kind"] == "youtube#video": videos.append('\"%s\" (%s)' % ((search_result["snippet"]["title"]).decode('utf-8'), search_result["id"]["videoId"])) #videos = unicode(videos) #videos = videos.split('\n') #print "Videos:\n", "\n".join(videos), "\n" # Edit tracklist in JSON # {name: [name], id: [id]} tracklist = videos return tracklist #argparser.add_argument("--q", help="Search term", default="Google") #argparser.add_argument("--max-results", help="Max results", default=25) args = argparser.parse_args() print args return youtube_search(args, text)
def get_authenticated_service(): upload_scope = 'https://www.googleapis.com/auth/youtube.upload' flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=upload_scope) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args(args=['--noauth_local_webserver']) credentials = run_flow(flow, storage, flags) return build('youtube', 'v3', http=credentials.authorize(httplib2.Http()))
def build_youtube(): flow = flow_from_clientsecrets( CLIENT_SECRETS_FILE, message=MISSING_CLIENT_SECRETS_MESSAGE, scope=YOUTUBE_READ_WRITE_SCOPE ) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args() credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) return youtube
def google_auth(client_id, client_secret, scope): flow = OAuth2WebServerFlow(client_id=client_id, client_secret=client_secret, scope=scope, redirect_uri='http://localhost') storage = Storage('creds.data') flags = argparser.parse_args(args=[]) credentials = run_flow(flow, storage, flags) access_token = credentials.access_token os.remove('creds.data') return access_token
def authentication(): # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains # the OAuth 2.0 information for this application, including its client_id and # client_secret. You can acquire an OAuth 2.0 client ID and client secret from # the Google Developers Console at # https://console.developers.google.com/. # Please ensure that you have enabled the YouTube Data API for your project. # For more information about using OAuth2 to access the YouTube Data API, see: # https://developers.google.com/youtube/v3/guides/authentication # For more information about the client_secrets.json file format, see: # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets CLIENT_SECRETS_FILE = "client_secrets.json" # This variable defines a message to display if the CLIENT_SECRETS_FILE is # missing. MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the Developers Console https://console.developers.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account. YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, message=MISSING_CLIENT_SECRETS_MESSAGE, scope=YOUTUBE_READ_WRITE_SCOPE) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args() credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) return youtube;
def upload(file, title, desc): args = argparser.parse_args() args.file = file args.title = title args.description = desc youtube = get_authenticated_service(args) try: return initialize_upload(youtube, args) except HttpError as e: print("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content))
def _get_youtube_service(): flow = flow_from_clientsecrets(settings.GOOGLE_API_CREDENTIALS, scope='https://www.googleapis.com/auth/youtube') storage = Storage(os.path.join(settings.DATA_ROOT, 'google-credentials-oauth.json')) credentials = storage.get() if credentials is None or credentials.invalid: args = sys.argv[2:] args.append('--noauth_local_webserver') credentials = run_flow(flow, storage, argparser.parse_args(args)) return build('youtube', 'v3', http=credentials.authorize(httplib2.Http()))
def get_authenticated_service(args): log.info("youtube.get_authenticated_service") with tempfile.NamedTemporaryFile() as temp: temp.write(client_secrets.encode('utf-8')) temp.flush() flow = flow_from_clientsecrets(temp.name, scope=YOUTUBE_UPLOAD_SCOPE, message="missing client_secrets.json") storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run_flow(flow, storage, argparser.parse_args()) auth = credentials.authorize(httplib2.Http()) return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=auth)
def get_authenticated_service(init=False): flow = flow_from_clientsecrets("application_secrets.json", scope=YOUTUBE_READ_WRITE_SCOPE, message=MISSING_CLIENT_SECRETS_MESSAGE) storage = Storage("user_oauth2.json") credentials = storage.get() if init and (credentials is None or credentials.invalid): args = argparser.parse_args(["--noauth_local_webserver"]) credentials = run_flow(flow, storage, args) return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http()))
YOUTUBE_API_VERSION = "v3" u1 = "" u2 = "" u3 = "" u4 = "" u5 = "" argparser.add_argument("--q", help="Search term", default=random.choice(newlist)) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, developerKey=DEVELOPER_KEY) argparser.add_argument("--max-results", help="Max results", default=5) options = argparser.parse_args() search_response = youtube.search().list( q=options.q, part="id,snippet", maxResults=options.max_results).execute() videos = [] channels = [] playlists = [] for search_result in search_response.get("items", []): if search_result["id"]["kind"] == "youtube#video": videos.append("%s " % (search_result["id"]["videoId"])) u1 = videos[0] u2 = videos[1] u3 = videos[2]
# the Google APIs Console FLOW = OAuth2WebServerFlow(client_id=client_id, client_secret=client_secret, scope=scope, user_agent=user_agent) # To disable the local server feature, uncomment the following line: # FLAGS.auth_local_webserver = False # If the Credentials don't exist or are invalid, run through the native client # flow. The Storage object will ensure that if successful the good # Credentials will get written back to a file. storage = Storage('calendar.dat') credentials = storage.get() if credentials is None or credentials.invalid == True: credentials = run_flow(FLOW, storage, argparser.parse_args([])) # Create an httplib2.Http object to handle our HTTP requests and authorize it # with our good Credentials. http = httplib2.Http() http = credentials.authorize(http) # Build a service object for interacting with the API. Visit # the Google APIs Console # to get a developerKey for your own application. service = build(serviceName='calendar', version='v3', http=http, developerKey=developerKey)
def add_to_playlist(): # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains # the OAuth 2.0 information for this application, including its client_id and # client_secret. You can acquire an OAuth 2.0 client ID and client secret from # the Google Developers Console at # https://console.developers.google.com/. # Please ensure that you have enabled the YouTube Data API for your project. # For more information about using OAuth2 to access the YouTube Data API, see: # https://developers.google.com/youtube/v3/guides/authentication # For more information about the client_secrets.json file format, see: # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets CLIENT_SECRETS_FILE = "client_secret_903221304600-cqh20m4v1fitiu8u9okgrh2k27t0is67.apps.googleusercontent.com.json" # This variable defines a message to display if the CLIENT_SECRETS_FILE is # missing. MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the Developers Console https://console.developers.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account. YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, message=MISSING_CLIENT_SECRETS_MESSAGE, scope=YOUTUBE_READ_WRITE_SCOPE) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args() credentials = run_flow(flow, storage, flags) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) add_video_request = youtube.playlistItems().insert( part="snippet", body={ 'snippet': { 'playlistId': globals.YOUTUBE_PLAYLIST, 'resourceId': { 'kind': 'youtube#video', 'videoId': video_id[0].strip("()") } #'position': 0 } } ).execute()
def search_args_parse(): argparser.add_argument("--q", help="Search term", default="Google") argparser.add_argument("--max-results", help="Max results", default=25) args = argparser.parse_args() return args
def gather(search_query): argparser.add_argument("--q", help="Search term", default=search_query) argparser.add_argument("--max-results", help="Max results", default=50) arguments = argparser.parse_args() options = arguments youtube = build(API_NAME, API_VERSION, developerKey=API_KEY) search_response = youtube.search().list( q=options.q, type="video", part="id,snippet", maxResults=options.max_results).execute() videos = {} for search_result in search_response.get("items", []): if search_result["id"]["kind"] == "youtube#video": videos[search_result["id"] ["videoId"]] = search_result["snippet"]["title"] s = ','.join(videos.keys()) videos_list_response = youtube.videos().list( id=s, part='id,statistics,snippet,status,contentDetails').execute() res = [] for i in videos_list_response['items']: temp_res = dict(v_id=i['id'], v_title=videos[i['id']]) temp_res.update(i['statistics']) temp_res.update(i['status']) temp_res.update(i['contentDetails']) temp_res.update(i['snippet']) channel_details = cd.get_all_data(temp_res['channelId']) res.append(temp_res) temp_res.update(channel_details) dataframe = pd.DataFrame.from_dict(res) # drop useless columns from dataframe try: dataframe.drop([ 'license', 'licensedContent', 'dimension', 'thumbnails', 'v_title', 'uploadStatus', 'defaultLanguage' ], axis=1, inplace=True) except ValueError: dataframe.drop([ 'license', 'licensedContent', 'dimension', 'thumbnails', 'v_title', 'uploadStatus' ], axis=1, inplace=True) dataframe.drop(['caption', 'embeddable'], axis=1, inplace=True) try: dataframe.drop(['contentRating'], axis=1, inplace=True) except ValueError: pass try: dataframe.drop(['defaultAudioLanguage'], axis=1, inplace=True) except ValueError: pass try: dataframe.drop(['regionRestriction'], axis=1, inplace=True) except ValueError: pass names = dataframe.columns.values f = open("data.csv", "a") dataframe.to_csv(path_or_buf=f, encoding='utf-8') f.close()
except Exception, e: print str(e) pass print "Videos:\n", "\n".join(videos), "\n" print "Channels:\n", "\n".join(channels), "\n" print "Playlists:\n", "\n".join(playlists), "\n" s = search_response.get('nextPageToken', None) if __name__ == "__main__": f = open('colors.txt', 'r') h = open('errors.txt', 'w') primary_colors = [] for i in f: primary_colors.append(i.strip()) argparser.add_argument("--q", help="Search term", default='Color') argparser.add_argument("--max-results", help="Max results", default=25) for i in primary_colors: args = argparser.parse_args(("--q %s" % (i)).split()) print args try: youtube_search(args) except HttpError, e: print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)
def login(): global youtube args = argparser.parse_args() youtube = get_authenticated_service( args) #authenticates the api and saves it to youtube getLiveId(youtube)