def youtube_setup(course_id, force_load=False): global api_youtube global api_youtube_analytics youtube_scopes = ["https://www.googleapis.com/auth/youtube.readonly", "https://www.googleapis.com/auth/yt-analytics.readonly"] youtube_servicename = "youtube" youtube_version = "v3" youtube_analytics_servicename = "youtubeAnalytics" youtube_analytics_version = "v1" flow = OAuth2WebServerFlow(client_id=settings.YOUTUBE_CLIENT_ID, client_secret=settings.YOUTUBE_CLIENT_SECRET, scope=" ".join(youtube_scopes)) storage = Storage("cache/youtube_"+course_id+"_oauth2.json") youtube_credentials = storage.get() print "AAA" print youtube_credentials print "BBB" if youtube_credentials is None or youtube_credentials.invalid: if not force_load: return False youtube_credentials = run_flow(flow, storage) # youtube_credentials = run(flow, storage) http = youtube_credentials.authorize(httplib2.Http()) api_youtube = build(youtube_servicename, youtube_version, http=http) api_youtube_analytics = build(youtube_analytics_servicename, youtube_analytics_version, http=http) return True
def handle(self, *args, **options): print("=" * 50) print(" Login to Google Calendar API") print("=" * 50) flow = flow_from_clientsecrets( settings.GOOGLE_CALENDAR_CLIENT_SECRETS, scope='https://www.googleapis.com/auth/calendar', redirect_uri='urn:ietf:wg:oauth:2.0:oob') auth_uri = flow.step1_get_authorize_url() print("Open the following URL to authorize the API") print() print(auth_uri) print() code = input("Please fill the code: ") if not code: print("Canceled") exit(1) credentials = flow.step2_exchange(code) storage = Storage(settings.GOOGLE_CALENDAR_CREDENTIALS) storage.put(credentials) print("Credentials are saved in '{}'".format( settings.GOOGLE_CALENDAR_CREDENTIALS))
def setup(self, client_secrets): storage = Storage("credentials.dat") credentials = storage.get() if credentials is None or credentials.invalid: flow = flow_from_clientsecrets( client_secrets, scope="https://www.googleapis.com/auth/genomics", message="You need to copy a client_secrets.json file into this directory, " "or pass in the --client_secrets_filename option to specify where " "one exists. See the README for more help.", ) # There's probably a better way to generate the 'flags' object. Doing it this way for now. parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter, parents=[tools.argparser] ) parser.add_argument( "--client_secrets_filename", default=client_secrets, help="The filename of a client_secrets.json file from a " 'Google "Client ID for native application" that ' "has the Genomics API enabled.", ) flags = parser.parse_args() credentials = run_flow(flow, storage, flags) # Create a genomics API service http = httplib2.Http() http = credentials.authorize(http) service = build("genomics", "v1beta2", http=http) return service
def get_bigquery_jobs_service (authdir, args): """`args` should be a list of command-line arguments *not* containing the traditional `argv[0]` value. """ import httplib2 from oauth2client.file import Storage from oauth2client.client import flow_from_clientsecrets from oauth2client.tools import argparser, run_flow from googleapiclient.discovery import build storage = Storage (os.path.join (authdir, BQ_CREDENTIALS_FILE)) credentials = storage.get () projid = read_secret_line (os.path.join (authdir, BQ_PROJECT_FILE)) if credentials is None or credentials.invalid: flow = flow_from_clientsecrets (os.path.join (authdir, BQ_SECRETS_FILE), scope='https://www.googleapis.com/auth/bigquery') parser = argparse.ArgumentParser (description='bigquery auth', parents=[argparser]) flags = parser.parse_args (args) credentials = run_flow (flow, storage, flags) http = httplib2.Http () http = credentials.authorize (http) bq = build ('bigquery', 'v2', http=http) # Hackity hack to not have to drag a projectId around. jobs = bq.jobs () jobs.my_project_id = projid return jobs
def get_credentials(): """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. """ home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'pill_cal.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME if flags: credentials = tools.run_flow(flow, store, flags) else: # Needed only for compatibility with Python 2.6 credentials = tools.run(flow, store) print('Storing credentials to ' + credential_path) return credentials
def _connect(self, scope="https://www.googleapis.com/auth/drive", redirect_url="urn:ietf:wg:oauth:2.0:oob", saved_credentials="drive_cred.txt"): """ Start connection for Google drive :param scope: Service to access :param redirect_url: URI handled by application :param storage: Store authorization credentials to avoid auth every time """ flow = OAuth2WebServerFlow( self._key, self._secret, scope, redirect_url) storage = Storage(saved_credentials) credentials = storage.get() if credentials is None: auth_url = flow.step1_get_authorize_url() print '1. Go to: ' + auth_url print '2. Click "Allow" (you might have to log in first)' print '3. Copy the authorization code.' code = raw_input("Enter the authorization code here: ").strip() credentials = flow.step2_exchange(code) else: print 'Previous authorization will be used!' http = httplib2.Http() http = credentials.authorize(http) print "Authorization successful!" self._client = build("drive", "v2", http=http) storage.put(credentials)
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 main(argv): # create the orchestration object gce_cluster = GceCondor(None, PROJECT_ID) # create the top-level parser parser = argparse.ArgumentParser(parents=[argparser]) subparsers = parser.add_subparsers() # create the parser for the "start_cluster" command parser_start = subparsers.add_parser('start', help="start a condor cluster") parser_start.add_argument('node_count', type=int, default=1, help="the number of nodes, including master") parser_start.add_argument('-i', '--image', action="store_true", help="create instance from predefined image") parser_start.set_defaults(func=gce_cluster.start) # create the parser for the "terminate" command parser_terminate = subparsers.add_parser('terminate', help="shutdown cluster, ie terminate all instances in project") parser_terminate.set_defaults(func=gce_cluster.terminate) args = parser.parse_args(argv) # Perform OAuth 2.0 authorization. flow = flow_from_clientsecrets(CLIENT_SECRETS, scope=GCE_SCOPE) storage = Storage(OAUTH2_STORAGE) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run_flow(flow, storage, args) http = httplib2.Http() auth_http = credentials.authorize(http) # update the orchestration object with the authorized Http object gce_cluster.set_auth_http(auth_http) # perform the command args.func(args)
def revJSON(file_ID, file_Name): print "pulling credentials" myCreds = Storage('my_credentials.json') credentials = myCreds.get() print "authorizing HTTP request" http = httplib2.Http() http = credentials.authorize(http) print "building API resource" drive_service = build('drive', 'v2', http=http) data_file = time.strftime("Challenges/" + file_Name + ".json") try: directory = os.path.dirname(data_file) os.makedirs(directory) except: print "directory already exists" for revNum in xrange(1,300): print "calling API" stringRev = str(revNum) try: revisions = drive_service.revisions().get(fileId=file_ID, revisionId=stringRev).execute() rev = open(data_file, "a+") jRevs = json.dump(revisions, rev) rev.write("\n") rev.close() print "Saved Revision %d" % revNum except: print "Revision %d doesn't exist" % revNum
def OAuth2Login(client_secrets, credential_store, email): scope='https://picasaweb.google.com/data/' user_agent='picasawebuploader' storage = Storage(credential_store) credentials = storage.get() if credentials is None or credentials.invalid: flow = flow_from_clientsecrets(client_secrets, scope=scope, redirect_uri='urn:ietf:wg:oauth:2.0:oob') uri = flow.step1_get_authorize_url() webbrowser.open(uri) code = raw_input('Enter the authentication code: ').strip() credentials = flow.step2_exchange(code) if (credentials.token_expiry - datetime.utcnow()) < timedelta(minutes=5): http = httplib2.Http() http = credentials.authorize(http) credentials.refresh(http) storage.put(credentials) gd_client = gdata.photos.service.PhotosService(source=user_agent, email=email, additional_headers={'Authorization' : 'Bearer %s' % credentials.access_token}) return gd_client
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 get_credentials(calendar_name): """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. """ credentials_file = settings.CALENDAR_CREDENTIALS[calendar_name]["credentials_file"] client_secret_file = settings.CALENDAR_CREDENTIALS[calendar_name]["client_secret_file"] project_dir = os.path.dirname(os.path.realpath(__file__)) credential_dir = project_dir if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, credentials_file) store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: client_secret_file_path = os.path.join(project_dir, client_secret_file) flow = client.flow_from_clientsecrets(client_secret_file_path, SCOPES) flow.user_agent = APPLICATION_NAME flags = tools.argparser.parse_args(args=[]) credentials = tools.run_flow(flow, store, flags) logger.info('[google_calendar_backend] Storing GCal acccess credentials to ' + credential_path) return credentials
def test_pickle_and_json_interop(self): # Write a file with a pickled OAuth2Credentials. access_token = 'foo' client_id = 'some_client_id' client_secret = 'cOuDdkfjxxnv+' refresh_token = '1/0/a.df219fjls0' token_expiry = datetime.datetime.utcnow() token_uri = 'https://www.google.com/accounts/o8/oauth2/token' user_agent = 'refresh_checker/1.0' credentials = OAuth2Credentials( access_token, client_id, client_secret, refresh_token, token_expiry, token_uri, user_agent) f = open(FILENAME, 'w') pickle.dump(credentials, f) f.close() # Storage should be not be able to read that object, as the capability to # read and write credentials as pickled objects has been removed. s = Storage(FILENAME) read_credentials = s.get() self.assertEquals(None, read_credentials) # Now write it back out and confirm it has been rewritten as JSON s.put(credentials) f = file(FILENAME) data = simplejson.load(f) f.close() self.assertEquals(data['access_token'], 'foo') self.assertEquals(data['_class'], 'OAuth2Credentials') self.assertEquals(data['_module'], OAuth2Credentials.__module__)
def GetGoogleClient(filename): logging.debug("Creating Google client") credentials = Storage(filename).get() http = credentials.authorize(httplib2.Http()) client = build('fitness', 'v1', http=http) logging.debug("Google client created") return client
def _get_service(self): """Create and return the Google Calendar service object, using the credentials file generated through the command:: python manage.py --authorize The service object is used to make API requests to Google Calendar, but will raise IOError if the credentials file is not generated :raises: IOError, NotImplementedError :returns: The Google Calendar service. """ storage = Storage( e.eventum.app.config['EVENTUM_INSTALLED_APP_CREDENTIALS_PATH']) credentials = storage.get() if credentials is None: raise IOError if credentials.invalid is True: raise NotImplementedError http = httplib2.Http() http = credentials.authorize(http) return build('calendar', 'v3', http=http)
def get_email_service(config): """Return an authorized Gmail API service instance.""" google_client_secret_path = config.get_google_client_secret_path() print("google_client_secret_path: {0}".format(google_client_secret_path)) # The "scope" scope allows-- # "Create, read, update, and delete drafts. Send messages and drafts." # Check https://developers.google.com/gmail/api/auth/scopes for all # available scopes OAUTH_SCOPE = 'https://www.googleapis.com/auth/gmail.compose' # Start the OAuth flow to retrieve credentials flow = flow_from_clientsecrets(google_client_secret_path, scope=OAUTH_SCOPE) http = httplib2.Http() # Get default flags. parser = argparse.ArgumentParser(parents=[tools.argparser]) flags = parser.parse_args([]) print("debug: flags: {0!r}".format(flags)) # Location of the credentials storage file storage_path = config.get_gmail_storage_path() storage = Storage(storage_path) # Try to retrieve credentials from storage or run the flow to generate them credentials = storage.get() if credentials is None or credentials.invalid: credentials = tools.run_flow(flow, storage, flags=flags, http=http) # Authorize the httplib2.Http object with our credentials http = credentials.authorize(http) # Build the Gmail service from discovery gmail_service = build('gmail', 'v1', http=http) return gmail_service
def __init__(self, config_fields): """ Initialize the Google Drive handler using configuration dictionary fields. Args: config_fields (dict): String dictionary from the configuration segment Configuration Fields: access_token (str): Repository access token OAuth Interactive Configuration Fields: client_id (str): Client Id to use for OAuth validation client_secret (str): Client secret to use for OAuth validation cred_file (str): Full filepath to store credentials used for access. """ flow = OAuth2WebServerFlow(config_fields["client_id"], config_fields["client_secret"], self.SCOPES) try: storage = Storage(config_fields["cred_file"]) except: storage = Storage(os.path.join(os.path.dirname(os.path.realpath(__file__)), "gdc.dat")) credentials = storage.get() if credentials is None or credentials.invalid: credentials = tools.run_flow(flow, storage, flags=googledriveHandler.oauth_flags()) # Create an httplib2.Http object to handle our HTTP requests, and authorize it # using the credentials.authorize() function. http = httplib2.Http() http = credentials.authorize(http) self.client = discovery.build('drive', 'v3', http=http)
def oauth2_login(self): """ :return: """ user_agent = "picasawebuploader" storage = Storage(self.credential_storage + self.user + ".dat") credentials = storage.get() if credentials is None or credentials.invalid: print "Failed to get credential in cache. Going to get new" credentials = self.get_credentials() if (credentials.token_expiry - datetime.utcnow()) < timedelta(minutes=5): http = httplib2.Http() http = credentials.authorize(http) credentials.refresh(http) storage.put(credentials) gd_client = gdata.photos.service.PhotosService( source=user_agent, email=self.user + "@gmail.com", additional_headers={"Authorization": "Bearer %s" % credentials.access_token}, ) return gd_client
def main(): client_secrets_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'client_secrets.json') flow = flow_from_clientsecrets(client_secrets_path, scope='https://www.googleapis.com/auth/bigquery') storage = Storage('bigquery_credentials.dat') credentials = storage.get() if credentials is None or credentials.invalid: # Run oauth2 flow with default arguments. credentials = tools.run_flow(flow, storage, tools.argparser.parse_args([])) http = httplib2.Http() http = credentials.authorize(http) # todo: make a dataset and table? service = build('bigquery', 'v2', http=http) projectId = '907668440978' datasetId = 'isb_cgc' targetTableId = 'fmdata_egfr' sourceCSV = ['gs://fmdata/allDataMerge.EGFR.blankNA.csv'] loadTable(service, projectId, datasetId, targetTableId, sourceCSV, schema_fm)
def authorized_http(client_id, client_secret, apps, file=None): """ Start an authorized HTTP session. Try fetching valid user credentials from storage. If nothing has been stored, or if the stored credentials are invalid, complete the OAuth2 flow to obtain new credentials. """ if not os.path.exists(CREDENTIAL_DIR): os.makedirs(CREDENTIAL_DIR) credential_path = file or CREDENTIAL_PATH storage = Storage(credential_path) credentials = storage.get() scopes = set([ "https://www.googleapis.com/auth/{0}.readonly".format(app) for app in apps ]) if (not credentials or credentials.invalid or not scopes <= credentials.scopes): flow = OAuth2WebServerFlow( client_id=client_id, client_secret=client_secret, scope=scopes, redirect_uri=REDIRECT_URI) flow.user_agent = USER_AGENT # Do not parse did command-line options by OAuth client flags = tools.argparser.parse_args(args=[]) credentials = tools.run_flow(flow, storage, flags) return credentials.authorize(httplib2.Http())
def build(*args, **kwargs): ip = get_ipython() if 'google_credential_path' in kwargs: credential_path = kwargs['google_credential_path'] del kwargs['google_credential_path'] elif 'Googleapihelper' in ip.config and 'credential_path' in ip.config.Googleapihelper: credential_path = ip.config.Googleapihelper['credential_path'] else: logger.info('Credential store path not specified, trying default: '+ DEFAULT_CREDENTIALS_PATH) credential_path = DEFAULT_CREDENTIALS_PATH if 'google_secrets_path' in kwargs: secrets_path = kwargs['google_secrets_path'] del kwargs['google_secrets_path'] elif 'Googleapihelper' in ip.config and 'secrets_path' in ip.config.Googleapihelper: secrets_path = ip.config.Googleapihelper['secrets_path'] else: logger.info('Secrets path not specified, trying default: '+ DEFAULT_SECRETS_PATH) secrets_path = DEFAULT_SECRETS_PATH if 'redirect_uri' in kwargs: redirect_uri = kwargs['redirect_uri'] del kwargs['redirect_uri'] elif 'Googleapihelper' in ip.config and 'redirect_uri' in ip.config.Googleapihelper: redirect_uri = ip.config.Googleapihelper['redirect_uri'] else: logger.info('Redirect uri not specified, trying default: '+ DEFAULT_REDIRECT_URI) redirect_uri = DEFAULT_REDIRECT_URI if 'scope' in kwargs: scope = kwargs['scope'] del kwargs['scope'] elif 'Googleapihelper' in ip.config and 'scope' in ip.config.Googleapihelper: scope = ip.config.Googleapihelper['scope'] else: logger.error('No scope specified in options or ipython config. '+ 'Store scope in ipython profile or specify on command line.') return None storage = Storage(credential_path) credentials = storage.get() if credentials is None: flow = flow_from_clientsecrets(secrets_path, scope=scope, redirect_uri=redirect_uri) flags, kwargs = extract_flags_from_kwargs(kwargs) tools.run_flow(flow, storage, flags) credentials = storage.get() if credentials is None: logger.error("Unable to retrieve google oauth credentials") return None http = httplib2.Http() http = credentials.authorize(http) kwargs['http'] = http return discovery.build(*args, **kwargs)
def __init__(self, job_description, saga_url, pilot_compute_description): self.job_description = job_description self.saga_url = saga_url self.pilot_compute_description = pilot_compute_description self.image_url = GCE_IMAGE_URL if self.pilot_compute_description.has_key("vm_id"): self.image_url = self.pilot_compute_description["vm_id"] self.machine_type = "https://www.googleapis.com/compute/v1beta12/projects/bigjob-pilot/machine-types/n1-standard-1" if self.pilot_compute_description.has_key("vm_type"): self.machine_type = self.pilot_compute_description["vm_type"] self.location = "https://www.googleapis.com/compute/v1beta12/projects/bigjob-pilot/zones/us-east1-a" if self.pilot_compute_description.has_key("vm_location"): self.location = self.pilot_compute_description["vm_location"] self.id="bigjob-" + str(uuid.uuid1()) self.network_ip=None # Do OAUTH authentication storage = Storage('gce.dat') self.credentials = storage.get() if self.credentials is None or self.credentials.invalid == True: flow = OAuth2WebServerFlow( client_id=OAUTH2_CLIENT_ID, client_secret=OAUTH2_CLIENT_SECRET, scope='https://www.googleapis.com/auth/compute', user_agent='bigjob-client/1.0') self.credentials = run(flow, storage)
def get_authenticated_service(oauth_file): args = namedtuple('flags', [ 'noauth_local_webserver', 'logging_level' ] ) args.noauth_local_webserver = True args.logging_level='ERROR' # how and where tokens are stored storage = Storage(oauth_file) # http://google-api-python-client.googlecode.com/hg/docs/epy/oauth2client.multistore_file-module.html credentials = storage.get() if credentials is None or credentials.invalid: flow = flow_from_clientsecrets( CLIENT_SECRETS_FILE, scope=YOUTUBE_READ_WRITE_SCOPE,) # do the "allow access" step, save token. credentials = run_flow(flow, storage, args) return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http()))
def Authenticate(self): f = Auth(KEYS_FILE) # OAuth 2.0 Authentication flow = OAuth2WebServerFlow( client_id=f.GetClientId(), client_secret=f.GetClientSecret(), scope='https://www.googleapis.com/auth/tasks', user_agent='Tasky/v1') # If 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(os.path.join(TASKY_DIR, 'tasks.dat')) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run(flow, storage) http = httplib2.Http() http = credentials.authorize(http) # The main Tasks API object. self.service = build( serviceName='tasks', version='v1', http=http, developerKey=f.GetApiKey())
def __build_service(self): """ Creates the service object and based on the credentials stored in config.py """ flow = OAuth2WebServerFlow( client_id=config.client_id, client_secret=config.client_secret, scope='https://www.googleapis.com/auth/calendar', user_agent=config.user_agent) storage = Storage(self.credentials_filename) credentials = storage.get() if credentials is None or credentials.invalid == True: credentials = run(flow, storage) http = httplib2.Http() http = credentials.authorize(http) service = build( serviceName="calendar", version="v3", http=http, developerKey=config.developer_key) return service
def refreshCredentials(self): storage = Storage('credentials.dat') credentials = storage.get() # Create an httplib2.Http object and authorize it with our credentials http = httplib2.Http() credentials.refresh(http) return credentials
def main(): storage = Storage('bigquery_credentials.dat') credentials = storage.get() if credentials is None or credentials.invalid: # Run oauth2 flow with default arguments. credentials = tools.run_flow(FLOW, storage, tools.argparser.parse_args([])) http = httplib2.Http() http = credentials.authorize(http) bigquery_service = build('bigquery', 'v2', http=http) try: query_request = bigquery_service.jobs() query_data = {'query':'SELECT TOP( title, 10) as title, COUNT(*) as revision_count FROM [publicdata:samples.wikipedia] WHERE wp_namespace = 0;'} query_response = query_request.query(projectId=PROJECT_NUMBER, body=query_data).execute() print 'Query Results:' for row in query_response['rows']: result_row = [] for field in row['f']: result_row.append(field['v']) print ('\t').join(result_row) except HttpError as err: print 'Error:', pprint.pprint(err.content) except AccessTokenRefreshError: print ("Credentials have been revoked or expired, please re-run" "the application to re-authorize")
def gdrive_login(self): """ Logins to the gdrive using the your credentials - no input needed""" # Authenticate and get a service object attempt_1=0 while attempt_1 < 4: try: # Send in client secret and client ID to the authetication server. Need to set this up in google developer console to get the client secrets and ID # Then need to also activate google analytics in the allowed applications flow = OAuth2WebServerFlow( self.client_id, self.client_secret, 'https://www.googleapis.com/auth/drive') # Stores the credentials in credentials.dat (i think) storage = Storage('credentials_gdrive.dat') credentials = storage.get() if credentials is None or credentials.invalid: credentials = run(flow, storage) # Use the credentials to get authentication? # Finally if this is the first time, your browser should pop to ask for login and permission allowing app http = httplib2.Http() http = credentials.authorize(http) self.service_gd = build('drive', 'v2', http=http) attempt_1=100 except Exception as e_connection: attempt_1+=1 self.logger.info('Exception is: '+str(e_connection)) self.logger.info('Attempt number '+str(attempt_1)) time.sleep(7) pass print ('Exception is: '+str(e_connection)+'\n'+'Attempt number '+str(attempt_1))
def get_biqquery_service(CLIENT_SECRET='client_secret_big_query.json'): FLOW = flow_from_clientsecrets(CLIENT_SECRET, scope='https://www.googleapis.com/auth/bigquery') flags = tools.argparser.parse_args(args=['--noauth_local_webserver']) storage = Storage('bigquery_credentials.dat') credentials = storage.get() if credentials is None or credentials.invalid: credentials = run_flow(FLOW, storage, flags) http = httplib2.Http() http = credentials.authorize(http) bigquery_service = build('bigquery', 'v2', http=http) try: # try retrieve some data datasets = bigquery_service.datasets() # listReply = datasets.list(projectId=PROJECT_NUMBER).execute() # if it runs OK, return the service return bigquery_service except HttpError as err: print 'Error in listDatasets:', pprint.pprint(err.content) except AccessTokenRefreshError: print ("Credentials have been revoked or expired, please re-run \ the application to re-authorize")
def GetCredentials(flags, scope_list): """Retrieve saved credentials or create and save credentials using flow. Args: flags: argparse parsed flags object. scope_list: List of strings reflecting desired API access (scope) e.g.: ['https://www.googleapis.com/auth/directory.user']. Returns: An oauth2client Credentials() object. """ client_file_storage = Storage( FILE_MANAGER.BuildFullPathToFileName(_CURRENT_ACCESS_FILE_NAME)) credentials = client_file_storage.get() if credentials is None or credentials.invalid: client_secrets_path = FILE_MANAGER.BuildFullPathToFileName( _CLIENT_SECRETS_FILE_NAME, work_dir=False) missing_secrets_msg = _MISSING_CLIENT_SECRETS_MSG % client_secrets_path flow_manager = flow_from_clientsecrets(client_secrets_path, scope=scope_list, message=missing_secrets_msg) credentials = run_flow(flow_manager, client_file_storage, flags) if not credentials: log_utils.LogError('Unable to retrieve valid credentials.') sys.exit(-1) return credentials
def get_credentials(): """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. """ home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'todoist_gcal_sync.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME if flags: credentials = tools.run_flow(flow, store, flags) log.info('Storing credentials to ' + credential_path) return credentials
def _load_credentials(self, credentials_file_path): if credentials_file_path == GCE_CREDENTIALS: return gce.AppAssertionCredentials(self._SCOPES) if credentials_file_path == APPENGINE_CREDENTIALS: # pragma: no cover # This import doesn't work outside appengine, so delay it until it's used. from oauth2client import appengine return appengine.AppAssertionCredentials(self._SCOPES) with open(credentials_file_path, 'r') as credentials_file: credentials_json = json.load(credentials_file) if credentials_json.get('type', None): credentials = GoogleCredentials.from_stream(credentials_file_path) credentials = credentials.create_scoped(self._SCOPES) return credentials return Storage(credentials_file_path).get()
def get_credentials(): """Gets valid user credentials from storage. If nothing has been stored, or if the stored credentials are invalid, the OAuth2 flow in completed to obtain the new credentials. Returns: Credentials, the obtained credential. """ home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'gmail-python-stats.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args() credentials = tools.run_flow(flow, store, flags) print('Storing credentials to ' + credential_path) return credentials
def get_credentials(self): """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. """ # home_dir = os.path.expanduser('~') # credential_dir = os.path.join(home_dir, '.credentials') # if not os.path.exists(credential_dir): # os.makedirs(credential_dir) # credential_path = os.path.join(credential_dir, # __file__ + '.json') credential_path = self.oauth store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(self.secrets, SCOPES) flow.user_agent = APPLICATION_NAME credentials = tools.run_flow(flow, store, self.flags) return credentials
def tryFetchingCredentials(): global credentials try: credentials = flow.step2_exchange(device_flow_info=deviceFlowInfo) except FlowExchangeError as e: if e.message != 'authorization_pending': raise ValueError('Unknown FlowExchange error: %s' % e.message) return False if credentials.invalid: credentials = None return False credentialsFile = File.fromNameAndDir(CREDENTIALS_FILE, YOUTUBE_DATA_DIR) storage = Storage( credentialsFile.fullpathTranslated()) #store on hard drive storage.put(credentials) return True #READ_ONLY_SCOPE = 'https://www.googleapis.com/auth/youtube.readonly' #REDIERCT_URI = 'urn:ietf:wg:oauth:2.0:oob' #directLink = flow.step1_get_authorize_url() #from oauth2client.client import OAuth2WebServerFlow #CLIENT_ID = '1074802623980-dpf5kf1o0e14hkjb9al8st51r2fqk71l.apps.googleusercontent.com' #CLIENT_SECRET = 'xCvTxLTqi0TbkWijXxYBS8_7' # flow = OAuth2WebServerFlow(client_id=CLIENT_ID, # client_secret=CLIENT_SECRET, # scope=READ_WRITE_SCOPE, # redirect_uri=REDIERCT_URI)
def _get_credentials(): """ 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. @return: The obtained credentials. """ # Make sure the credentials directory exists. If not, create it and store the credentials in there. home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, "google_sheets.json") # Try loading credentials from file store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: # Perform authentication flow = client.flow_from_clientsecrets(CREDENTIALS_FILE_PATH, SCOPES) flow.user_agent = APPLICATION_NAME credentials = tools.run_flow(flow, store) return credentials
def step2_exchange(now): """Keep trying to validate the user_code until it expires.""" if now >= dt.as_local(dev_flow.user_code_expiry): hass.components.persistent_notification.create( 'Authentication code expired, please restart ' 'Home-Assistant and try again', title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID) listener() try: credentials = oauth.step2_exchange(device_flow_info=dev_flow) except FlowExchangeError: # not ready yet, call again return storage = Storage(hass.config.path(TOKEN_FILE)) storage.put(credentials) do_setup(hass, config) listener() hass.components.persistent_notification.create( 'We are all setup now. Check {} for calendars that have ' 'been found'.format(YAML_DEVICES), title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID)
def createAuthorizedHTTP(self): storage = Storage('credentials.dat') credentials = storage.get() print "===> Credentials: ", credentials.to_json() # Create an httplib2.Http object and authorize it with our credentials http = httplib2.Http() if credentials is None: #TODO: print exception or authorize user print "Credentials does not exist!" if credentials.invalid: print "Refresh credentials(createAuthorizedHTTP)..." print "Credentials (Before refresh):" print credentials.to_json() credentials.refresh(http) print "Credentials (After refresh):" print credentials.to_json() # authorize http with credentials http = credentials.authorize(http) return http
def _get_authenticated_service(self): flow = flow_from_clientsecrets(self.client_secrets_file_path, scope=self.scopes, message="missing secrets message here!") storage = Storage(self.credentials_file_path) credentials = storage.get() class Args(object): pass args = Args() args.auth_host_name = 'localhost' args.auth_host_port = [8080, 8090] args.logging_level = 'ERROR' args.noauth_local_webserver = False if credentials is None or credentials.invalid: credentials = run_flow(flow, storage, args) return build(self.api_service, self.api_version, http=credentials.authorize(httplib2.Http()))
def get_credentials(): """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. """ home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join( credential_dir, 'sheets.googleapis.com-python-quickstart.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME credentials = tools.run(flow, store) print('Storing credentials to ' + credential_path) return credentials
def auth(self, force=False): if self.service != None or force: return self.service FLOW = OAuth2WebServerFlow( client_id=self.client_id, client_secret=self.client_secret, scope='https://www.googleapis.com/auth/calendar', user_agent='DIMVA2015/1.0') storage = Storage(self.creds_file) credentials = storage.get() if credentials is None or credentials.invalid == True: credentials = run(FLOW, storage) http = credentials.authorize(httplib2.Http()) service = build(serviceName='calendar', version='v3', http=http, developerKey=self.api_key) return service
def getAuthorizedHttp(): config = ConfigParser.ConfigParser() config.read([os.path.dirname(__file__) + '/config.ini']) # Copy your app credentials from the console CLIENT_ID = config.get('gdrive', 'CLIENT_ID') CLIENT_SECRET = config.get('gdrive', 'CLIENT_SECRET') # OAuth 2.0 scope that will be authorized. # Check https://developers.google.com/drive/scopes for all available scopes. OAUTH_SCOPE = 'https://www.googleapis.com/auth/drive' # Redirect URI for installed apps REDIRECT_URI = 'urn:ietf:wg:oauth:2.0:oob' # Init auth storage storage = Storage(os.path.dirname(__file__) + '/client_secrets.json') credentials = storage.get() # Check credentials existance if not credentials: # Perform OAuth2.0 authorization flow. flow = OAuth2WebServerFlow(CLIENT_ID, CLIENT_SECRET, OAUTH_SCOPE, REDIRECT_URI) authorize_url = flow.step1_get_authorize_url() print 'Go to the following link in your browser: ' + authorize_url code = raw_input('Enter verification code: ').strip() credentials = flow.step2_exchange(code) # Store allowed credentials storage.put(credentials) # Create an authorized Drive API client. http = httplib2.Http() credentials.authorize(http) return http
def create_credentials(name): config = get_config(name) if 'client_id' not in config \ or 'client_secret' not in config: print('Error: client_id, client_secret is not set.\n\n' 'Please create a client ID here and update ' 'config.py:\n\nhttps://code.google.com/apis/console/#:access') sys.exit(1) FLOW = OAuth2WebServerFlow( client_id=config['client_id'], client_secret=config['client_secret'], scope='https://www.googleapis.com/auth/{}.readonly'.format(name)) run_flags = tools.argparser.parse_args(args=[]) credentials_file = os.path.join(app.instance_path, 'jobs', '.{}.json'.format(name)) storage = Storage(credentials_file) credentials = storage.get() if credentials is None or credentials.invalid: credentials = tools.run_flow(FLOW, storage, run_flags) else: print('Google API credentials already exist: %s' % (credentials_file,))
def access_to_youtube(self): CLIENT_SECRETS_FILE = "client_id.json" MISSING_CLIENT_SECRETS_MESSAGE = 'WARNING: Please configure OAuth 2.0' # 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("oauth2.json") credentials = storage.get() if credentials is None or credentials.invalid: flags = argparser.parse_args() credentials = run_flow(flow, storage, flags) self.youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http()))
def get_people_service(self): # Set up a Flow object to be used if we need to authenticate. This # sample uses OAuth 2.0, and we set up the OAuth2WebServerFlow with # the information it needs to authenticate. Note that it is called # the Web Server Flow, but it can also handle the flow for # installed applications. # # Go to the Google API Console, open your application's # credentials page, and copy the client ID and client secret. # Then paste them into the following code. FLOW = OAuth2WebServerFlow( client_id=self.CLIENT_ID, client_secret=self.CLIENT_SECRET, scope='https://www.googleapis.com/auth/contacts.readonly', user_agent='addresslabel/%s' % self.app.VERSION if self.app is not None else "1.0.0") # If the Credentials don't exist or are invalid, run through the # installed application flow. The Storage object will ensure that, # if successful, the good Credentials will get written back to a # file. storage = Storage('info.dat') credentials = storage.get() if credentials is None or credentials.invalid == True: credentials = run_flow(FLOW, storage) # 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. To get an API key for # your application, visit the Google API Console # and look at your application's credentials page. people_service = build(serviceName='people', version='v1', http=http) return people_service
def get_credentials(self): # pragma: no cover """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. """ if not os.path.exists(self.cred): os.makedirs(self.cred) cred_file = os.path.join(self.cred, 'calendar-token.json') store = Storage(cred_file) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME if self.flags: credentials = tools.run_flow(flow, store, self.flags) else: # Needed only for compatibility with Python 2.6 credentials = tools.run(flow, store) print('Storing credentials to ' + cred_file) return credentials
def get_credentials(): """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. """ cur_dir = os.path.curdir credential_dir = os.path.join(cur_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'GCal-Cleanup.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME if flags: credentials = tools.run_flow(flow, store, flags) else: # Needed only for compatibility with Python 2.6 credentials = tools.run(flow, store) print('Storing credentials to ' + credential_path) return credentials
def getCredentials(self): """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. """ home_dir = os.getcwd() credential_path = os.path.join(home_dir, 'credential.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) flow.user_agent = APPLICATION_NAME flags.noauth_local_webserver = True credentials = tools.run_flow(flow, store, flags) logging.info('Storing credentials to ' + credential_path) http = credentials.authorize(httplib2.Http()) self.service = discovery.build('drive', 'v2', http=http)
def _credentials_procedure(self): home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join( credential_dir, 'wrh_uploader_%i.json' % int(self._file_id)) store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: try: import argparse flags = argparse.ArgumentParser( parents=[tools.argparser]).parse_args() except ImportError: flags = None flow = client.flow_from_clientsecrets(self._secret, self.SCOPES) flow.user_agent = self.APPLICATION_NAME flags.noauth_local_webserver = True credentials = tools.run_flow(flow, store, flags) log('Storing credentials to ' + credential_path) return credentials
def goog_cred(name): flow = client.flow_from_clientsecrets( 'client_secret.json', scope='https://www.googleapis.com/auth/calendar.readonly https://www.googleapis.com/auth/gmail.readonly', redirect_uri='urn:ietf:wg:oauth:2.0:oob') auth_uri = flow.step1_get_authorize_url() webbrowser.open(auth_uri) auth_code = input('Login and enter code here: ') file = str(name) + '_goog.txt' try: credentials = flow.step2_exchange(auth_code) storage = Storage(file) storage.put(credentials) return 1 except oauth2client.client.FlowExchangeError: fob = open(file, 'w') fob.write("None") fob.close() return 0
def get_credentials(): cwd = os.getcwd() flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args() client_secret_file = cwd+"/"+credential_name if not os.path.exists(client_secret_file): print "ERROR. The Google Sheet secret file "+client_secret_file+" does not exist. Not ablwe to get sourcetype <-> index mapping" exit() home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-break-main.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(client_secret_file, scopes) flow.user_agent = application_name credentials = tools.run_flow(flow, store, flags) #credentials = tools.run_flow(flow, store) return credentials
def authenticate() -> httplib2.Http: """ returns an Http instance that already contains the user credentials and is ready to make requests to alter user data. On the first time, this function will open the browser so that the user can grant it access to his data """ with open(APP_KEYS_FILE) as f: app_keys = json.load(f) storage = Storage(USER_OAUTH_DATA_FILE) credentials = storage.get() if credentials is None or credentials.invalid: credentials = tools.run_flow( OAuth2WebServerFlow( client_id=app_keys['APP_CLIENT_ID'], client_secret=app_keys['APP_CLIENT_SECRET'], scope=['https://www.googleapis.com/auth/reminders'], user_agent='google reminders cli tool'), storage, tools.argparser.parse_args([]) ) auth_http = credentials.authorize(httplib2.Http()) return auth_http
def _get_credentials(self): """Get OAuth credentials :return: OAuth credentials :rtype: :class:`oauth2client.client.Credentials` """ credential_dir = join(self.var_dir, 'cached_oauth_credentials') if not exists(credential_dir): makedirs(credential_dir) credential_path = join(credential_dir, 'googleapis.json') store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(self.config['creds'], self.config['scope']) flow.user_agent = 'Iris Gmail Integration' credentials = tools.run_flow( flow, store, tools.argparser.parse_args(args=['--noauth_local_webserver'])) logger.info('Storing credentials to %s', credential_path) else: credentials.refresh(self.http) return credentials
def _get_google_credentials(self): """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. """ home_dir = os.path.expanduser('~') credential_dir = os.path.join(home_dir, '.credentials') if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'garage-server.json') store = Storage(credential_path) credentials = store.get() ''' No interactive context in this module, so just fail ''' if not credentials or credentials.invalid: logger = logging.getLogger(__name__) logger.error("Invalid Google Credentials") credentials = None return credentials
def get_credentials(): """ 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. """ #home_dir = os.path.expanduser('~') credential_dir = os.path.join(Filepath, '.credentials') CLIENT_SECRET_FILE = './OAuth/client_secret.json' if not os.path.exists(credential_dir): os.makedirs(credential_dir) credential_path = os.path.join(credential_dir, 'drive-python-quickstart.json') if not os.path.exists(CLIENT_SECRET_FILE): print('**Not find Client_Secret_FIle**') else: SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl'] store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES) if flags: credentials = tools.run_flow(flow, store, flags) else: credentials = tools.run_flow(flow, store) print('Storing credentials to ' + credential_path) return credentials
def get_credentials(self): """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_path = self._token_filename store = Storage(credential_path) credentials = store.get() if not credentials or credentials.invalid: flow = client.flow_from_clientsecrets(self._client_secrets, self._scope) flow.user_agent = APPLICATION_NAME if args: credentials = tools.run_flow(flow, store, args) else: # Needed only for compatibility with Python 2.6 credentials = tools.run(flow, store) print('Storing credentials to ' + credential_path) return credentials
def login(self, src_path): """ Login to Google API using data provided in config. :param src_path: path to calendar credentials :type src_path: str """ # The client_id and client_secret can be found in Google Developers Console flow = OAuth2WebServerFlow( client_id=self.config['client_id'], client_secret=self.config['client_secret'], scope='https://www.googleapis.com/auth/calendar', user_agent=self.user_agent) # To disable the local server feature, uncomment the following line: # import gflags # FLAGS = gflags.FLAGS # 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(src_path + '/calendar.dat') credentials = storage.get() if credentials is None or credentials.invalid is True: credentials = tools.run(flow, storage) # 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 Developers Console # to get a developerKey for your own application. self.service = build(serviceName='calendar', version='v3', http=http, developerKey='notsosecret')
def _load_user_credentials(scope, app_cred, user_cred_file=default_user_cred_file, log=None): # Get user consent client_id = app_cred['installed']['client_id'] client_secret = app_cred['installed']['client_secret'] flow = OAuth2WebServerFlow(client_id, client_secret, scope) flow.user_agent = user_agent storage = Storage(user_cred_file) user_cred = storage.get() # If no credentials are able to be loaded, fire up a web # browser to get a user login, etc. Then save those # credentials in the file listed above so that next time we # run, those credentials are available. if user_cred is None or user_cred.invalid: user_cred = tools.run_flow(flow, storage, tools.argparser.parse_args()) if log: log.debug('Loaded user credentials from {0}'.format(user_cred_file)) return user_cred
def gmailauth(self, setType): scope = ("https://www.googleapis.com/auth/%s" % (setType)) # create flow object flow = OAuth2WebServerFlow(self.client_id, self.client_secret, scope) # create / refresh credentials storage = Storage(".%s_credentials.dat" % (setType)) credentials = storage.get() if credentials is None or credentials.invalid: credentials = tools.run_flow(flow, storage, tools.argparser.parse_args()) # create / authorize http object to handle HTTP requests http = httplib2.Http() http = credentials.authorize(http) # create object to make API calls if "admin" in setType: service = build("admin", "directory_v1", http=http) elif "gmail" in setType: service = build("gmail", "v1", http=http) return service
def get_authenticated_service(): """Get youtube credentials identified. """ try: youtube_uploader = settings.YOUTUBE_UPLOADER except Exception as e: raise ValueError(e) scope = youtube_uploader['scope'] credentials_path = youtube_uploader['credentials_path'] client_info = youtube_uploader['client_info'] credentials_file = youtube_uploader['credentials_file'] my_flow_from_clientsecrets(client_info, scope) module_dir = os.path.abspath(credentials_path) file_path = os.path.join(module_dir, credentials_file) storage = Storage(file_path) credentials = storage.get() try: builded = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) return builded except Exception as e: print(("error", e))