def __init__(self): if USE_APPLESCRIPT is False: if not mw.col.conf.get(SETTING_TOKEN, False): # First run of the Plugin we did not save the access key yet client = EvernoteClient( consumer_key='scriptkiddi-2682', consumer_secret='965f1873e4df583c', sandbox=False ) request_token = client.get_request_token('https://fap-studios.de/anknotes/index.html') url = client.get_authorize_url(request_token) showInfo("We will open a Evernote Tab in your browser so you can allow access to your account") openLink(url) oauth_verifier = getText(prompt="Please copy the code that showed up, after allowing access, in here")[0] auth_token = client.get_access_token( request_token.get('oauth_token'), request_token.get('oauth_token_secret'), oauth_verifier) mw.col.conf[SETTING_TOKEN] = auth_token else: auth_token = mw.col.conf.get(SETTING_TOKEN, False) self.token = auth_token self.client = EvernoteClient(token=auth_token, sandbox=False) self.noteStore = self.client.get_note_store()
def __init__(self): if not mw.col.conf.get(SETTING_TOKEN, False): # First run of the Plugin we did not save the access key yet client = EvernoteClient( consumer_key='scriptkiddi-2682', consumer_secret='965f1873e4df583c', sandbox=False ) request_token = client.get_request_token('http://brunomart.in/anknotes/index.html') url = client.get_authorize_url(request_token) showInfo("We will open a Evernote Tab in your browser so you can allow access to your account") openLink(url) oauth_verifier = getText(prompt="Please copy the code that showed up, after allowing access, in here")[0] secret_key = getText(prompt="protect your value with a password, it will be asked each time you import your notes")[0] auth_token = client.get_access_token( request_token.get('oauth_token'), request_token.get('oauth_token_secret'), oauth_verifier) mw.col.conf[SETTING_TOKEN] = encode(secret_key, auth_token) else: secret_key = getText(prompt="password")[0] auth_token_encoded = mw.col.conf.get(SETTING_TOKEN, False) auth_token = decode(secret_key, auth_token_encoded) self.token = auth_token self.client = EvernoteClient(token=auth_token, sandbox=False) self.noteStore = self.client.get_note_store()
def setup(): ''' oauth flow for new users or updating users most of this was shamelessly copied from : https://gist.github.com/inkedmn/5041037 ''' client = EvernoteClient( consumer_key = config.CONSUMER_KEY, consumer_secret = config.CONSUMER_SECRET, sandbox = False ) request_token = client.get_request_token('http://localhost:10668') print "Paste this URL in your browser and login:"******"Token saved."
def setup(): """ oauth flow for new users or updating users adapted from https://gist.github.com/inkedmn/5041037 """ client = EvernoteClient( consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, sandbox=False ) request_token = client.get_request_token('http://localhost:10668') print( "Paste this URL in your browser and login:"******"-> {url} \n\n" "Be advised, this will save your oauth token in plaintext to ~/.not_token !" "if you aren't cool with that, ctrl-c now and never return!".format( url=client.get_authorize_url(request_token) ) ) single_server = single_serve() single_server.handle_request() auth_url = path # noqa vals = parse_query_string(auth_url) auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier'] ) with open(os.path.join(os.environ['HOME'], '.not_token'), 'w') as f: f.write(auth_token) print("Token saved.")
def authorize(self, storage_name): '''Authorize/reauthorize the app if something is wrong with the token or storage. ''' # Start oauth flow client = EvernoteClient(consumer_key=self.consumer_key, consumer_secret=self.consumer_secret, sandbox=False) request_token = client.get_request_token('http://localhost') #Prompt the user to open the request URL in their browser print "Paste this URL in your browser and login\n" print client.get_authorize_url(request_token) + '\n' # Have the user paste the resulting URL so we can pull it # apart print "Paste the URL after login here:" authurl = raw_input() ## Parse the URL to get the OAuth verifier vals = self.parse_query_string(authurl) # Use the OAuth verifier and the values from request_token # to built the request for our authentication token, then # ask for it. auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier']) # We will need it for some methods self.token = auth_token # Write it to the storage file try: storage = open(storage_name, 'w') storage.write(auth_token) except ImportError, e: # Should never happen print 'Error while saving the auth token: ', e print 'Your auth token is: ', auth_token
def setup(): """ oauth flow for new users or updating users adapted from https://gist.github.com/inkedmn/5041037 """ client = EvernoteClient(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, sandbox=False) request_token = client.get_request_token('http://localhost:10668') print( "Paste this URL in your browser and login:"******"-> {url} \n\n" "Be advised, this will save your oauth token in plaintext to ~/.not_token !" "if you aren't cool with that, ctrl-c now and never return!".format( url=client.get_authorize_url(request_token))) single_server = single_serve() single_server.handle_request() auth_url = path # noqa vals = parse_query_string(auth_url) auth_token = client.get_access_token(request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier']) with open(os.path.join(os.environ['HOME'], '.not_token'), 'w') as f: f.write(auth_token) print("Token saved.")
def auth(): """Takes a callback for Evernote's OAuth process Redirect to main after login is confirmed an token is stored in the session""" #check to make sure the user approved the appliction (oauth_verifier will not be present if they declined) if "oauth_verifier" in request.args: #setup client client = EvernoteClient( consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, sandbox= sandbox ) #get access token try: auth_token = client.get_access_token(session['oauth_token'], session['oauth_token_secret'], request.args['oauth_verifier']) except: return render_template("error.html", error_message="OAuth Error: Please approve access to the appliction %s" % CONSUMER_KEY) #attach the user's access token to the session session["access_token"]=auth_token #redirect to main return redirect(url_for("main")) #If the user did not approve access to our application let the user know else: return render_template("error.html", error_message="OAuth Error: Please approve access to the appliction %s" % CONSUMER_KEY)
class OAuthView(QWebView): accessTokenChanged = Signal(str) def __init__(self, parent=None): QWebView.__init__(self) self.urlChanged.connect(self.pageChanged) conf = ConfigParser.SafeConfigParser() conf.read(CONFIG_FILE) consumer_key = conf.get('API', 'consumer_key') consumer_secret = conf.get('API', 'consumer_secret') self.client = EvernoteClient( consumer_key=consumer_key, consumer_secret=consumer_secret, sandbox=True) self.request_token = self.client.get_request_token('https://www.google.co.jp/') url = self.client.get_authorize_url(self.request_token) self.load(url) @Slot(QUrl) def pageChanged(self, url): queries = url.queryItems() if len(queries) == 2 and queries[1][0] == u'oauth_verifier': self.hide() self.access_token = self.client.get_access_token( self.request_token['oauth_token'], self.request_token['oauth_token_secret'], queries[1][1] ) self.accessTokenChanged.emit(self.access_token)
def on_navigation_requested(self, view, frame, req, data=None): logging.debug('Requesting new page') self.__spinner.show() self.__status_label.set_text(AuthDialog.STATUS_MESSAGE_CONNECTING) url = req.get_uri() if PROGRAM_NAME.lower() in url: query = urlparse.urlparse(url).query data = dict(urlparse.parse_qsl(query)) try: self.__authData['oauth_verifier'] = data['oauth_verifier'] except KeyError: logging.error('authorization failed') return False client = EvernoteClient( consumer_key=EverNoteConsumerInfo.CONSUMER_KEY, consumer_secret=EverNoteConsumerInfo.CONSUMER_SECRET, service_host = MetaData.get_evernote_host(), sandbox=False # Default: True ) self.__auth_token = client.get_access_token( self.__authData['oauth_token'], self.__authData['oauth_token_secret'], self.__authData['oauth_verifier'] ) self.__dialog.response(100) return False
def getAuthToken(self, c_key, c_secret): ## # Create an instance of EvernoteClient using your API # key (consumer key and consumer secret) ## client = EvernoteClient( consumer_key=c_key, consumer_secret=c_secret, sandbox=False # Default: True ) ## # Provide the URL where the Evernote Cloud API should # redirect the user after the request token has been # generated. In this example, localhost is used; note # that in this example, we're copying the URLs manually # and that, in production, this URL will need to # automatically parse the response and send the user # to the next step in the flow. ## request_token = client.get_request_token('http://localhost') ## # Prompt the user to open the request URL in their browser ## print "Paste this URL in your browser and login" print print '\t'+client.get_authorize_url(request_token) print print '-------' ## # Have the user paste the resulting URL so we can pull it # apart ## print "Paste the URL after login here:" authurl = raw_input() ## # Parse the URL to get the OAuth verifier ## vals = parse_query_string(authurl) ## # Use the OAuth verifier and the values from request_token # to built the request for our authentication token, then # ask for it. ## auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier'] ) return auth_token
def request_oauth_token(sandbox=False): client = EvernoteClient(consumer_key=MY_CONSUMER_KEY, consumer_secret=MY_CONSUMER_SECRET, sandbox=sandbox) resp_server = CLEVERNOTE_AUTH_WEB_SERVER # resp_server = 'http://localhost:8090/oauth' req_token = client.get_request_token(resp_server) webbrowser.open_new_tab(client.get_authorize_url(req_token)) auth_string64 = str(raw_input("Auth String: ")) auth_string = base64.b64decode(auth_string64) auth_dict = pickle.loads(auth_string) oauth_token = auth_dict['token'] verifier = auth_dict['verifier'] access_token = client.get_access_token(oauth_token, req_token['oauth_token_secret'], verifier) return access_token
def request_evernote_token(): client = EvernoteClient(consumer_key=config.CONSUMER_KEY, consumer_secret=config.CONSUMER_SECRET, sandbox=config.SANDBOX) request_token = client.get_request_token(OAUTH_URL) print('Paste this URL in your browser and login') print(client.get_authorize_url(request_token)) print('Paste the URL after login here:') auth_url = input() values = parse_query_string(auth_url) auth_token = client.get_access_token(request_token['oauth_token'], request_token['oauth_token_secret'], values['oauth_verifier']) print('Auth done') return auth_token
def _get_evernote_token(app_debug): client = EvernoteClient( consumer_key=CONSUMER_KEY, consumer_secret =CONSUMER_SECRET, sandbox=SANDBOX_ENABLE ) request_token = client.get_request_token("http://gevernote/") if request_token['oauth_callback_confirmed']: url_callback = client.get_authorize_url(request_token) if app_debug: print ("URL: %s" % url_callback) print ("oauth_token: %s" % request_token['oauth_token']) print ("oauth_token_secret: %s" % request_token['oauth_token_secret']) window = AuthWindow(url_callback) window.show_all() Gtk.main() if app_debug: print ("oauth_verifier: %s" % window.oauth_verifier) if not (window.oauth_verifier == "None"): # get the token for authorization user_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], window.oauth_verifier ) else: # handle window closed by cancel and no token user_token = window.oauth_verifier Gtk.main_quit if app_debug: print ("user_token: %s" % user_token) elif app_debug: # need app error checking/message here print("bad callback") # Token available? return user_token
def auth(): if "oauth_verifier" in request.args: client = EvernoteClient( consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, sandbox= True ) try: auth_token = client.get_access_token(session['oauth_token'], session['oauth_token_secret'], request.args['oauth_verifier']) except: return render_template("error.html", error_message="OAuth Error: Please approve access to the appliction %s" % CONSUMER_KEY) session["access_token"]=auth_token return redirect(url_for("main")) else: return render_template("error.html", error_message="OAuth Error: Please approve access to the appliction %s" % CONSUMER_KEY)
def auth_finish(): """After the user has authorized this app on Evernote's website, they will be redirected back to this URL to finish the process.""" oauth_verifier = request.args.get('oauth_verifier', '') oauth_token = session['oauth_token'] oauth_token_secret = session['oauth_token_secret'] client = EvernoteClient(consumer_key=EN_CONSUMER_KEY, consumer_secret=EN_CONSUMER_SECRET,sandbox=False) authToken = client.get_access_token(oauth_token, oauth_token_secret, oauth_verifier) # session['identifier'] = authToken resp = make_response(redirect(url_for('get'))) resp.set_cookie('token', authToken) return resp
def get_client(): token = get_token() if not token: print 'Username:\t', username = raw_input() print 'Password:\t', password = raw_input() print '\n' client = EvernoteClient(consumer_key='freddieshoreditch-8876', consumer_secret='13801fb7745664f3', sandbox=False) req_token = client.get_request_token('http://localhost/') os_ = get_os() url_ = client.get_authorize_url(req_token) if (os_ == 'Mac OS X'): command = 'open {}'.format(url_) elif (os == 'Windows'): print 'Unimplemented for Windows.' sys.exit(3) elif (os == 'Linux or other'): print 'Unimplemented for Linux or other.' sys.exit(3) else: print 'Unimplemented for your operating system.' sys.exit(3) tries = 0 exit_code = -1 while (exit_code != 0 and tries < 5): tries += 1 exit_code = subprocess.call(command, shell=True) if exit_code != 0: print 'Could not open authorisation url, please open it manually:', print url_ print '\n\nPASTE the URL after logging in:\t' result = raw_input() vals = parse_query_string(result) token = client.get_access_token(req_token['oauth_token'], req_token['oauth_token_secret'], vals['oauth_verifier']) with open('token.json', 'w') as f: f.write(json.dumps(token)) return EvernoteClient(token=token), token
def get_client(): token = get_token() if not token: print "Username:\t", username = raw_input() print "Password:\t", password = raw_input() print "\n" client = EvernoteClient( consumer_key="freddieshoreditch-8876", consumer_secret="13801fb7745664f3", sandbox=False ) req_token = client.get_request_token("http://localhost/") os_ = get_os() url_ = client.get_authorize_url(req_token) if os_ == "Mac OS X": command = "open {}".format(url_) elif os == "Windows": print "Unimplemented for Windows." sys.exit(3) elif os == "Linux or other": print "Unimplemented for Linux or other." sys.exit(3) else: print "Unimplemented for your operating system." sys.exit(3) tries = 0 exit_code = -1 while exit_code != 0 and tries < 5: tries += 1 exit_code = subprocess.call(command, shell=True) if exit_code != 0: print "Could not open authorisation url, please open it manually:", print url_ print "\n\nPASTE the URL after logging in:\t" result = raw_input() vals = parse_query_string(result) token = client.get_access_token( req_token["oauth_token"], req_token["oauth_token_secret"], vals["oauth_verifier"] ) with open("token.json", "w") as f: f.write(json.dumps(token)) return EvernoteClient(token=token), token
def get_client_oauth(self): client = EvernoteClient(consumer_key = self.customer_key, consumer_secret = self.customer_secret, sandbox = self.is_sandbox) request_token = client.get_request_token(self.url) print request_token request_url = client.get_authorize_url(request_token) print request_url auth_url = raw_input() vals = parse_query_string(auth_url) auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier']) return client
def auth_evernote(): #import evernote.edam.userstore.constants as UserStoreConstants #import evernote.edam.type.ttypes as Types from evernote.api.client import EvernoteClient client = EvernoteClient( consumer_key = 'baschtik-3522', consumer_secret = '9851242b79ad58cd', sandbox = True, ) request_token = client.get_request_token('http://always-backup.com/external_auth/evernote/') try: text = '''\ 1) Go to: \n%s 1a) Make sure that you have the complete URL (Scroll to te right). 2) Click "Allow" (you might have to log in first) 3) You will get a Code. Copy it to the Clip-board ''' % client.get_authorize_url(request_token) except: d.msgbox("Sorry, Evernote reportet an error. " "I quit the setup and show you the Response from Evernote.") print request_token raise d.scrollbox( text, height=15, width=0) code, verifier = d.inputbox( "Now enter the code here:", width=150 ) if code != 0: sync_pairs() try: auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], verifier ) except: d.msgbox("There was an error gernerating the access token\n" "The profile will be saved, continue and edit it later." "Otherwise sync will not work""", height=10, width=50) auth_token = False return auth_token
def oauth(): client = EvernoteClient(consumer_key=conf.key, consumer_secret=conf.sec, sandbox=conf.env) token = client.get_request_token(conf.url) url = client.get_authorize_url(token) c = requests.session() c.get(url) print "==> Please Sign in. Never store your PASSWORD!" cnt = 3 while cnt: cnt -= 1 payload = {"login": "******", "targetUrl": url} if hasattr(conf, "username"): payload["username"] = conf.username else: payload["username"] = raw_input("Username: "******"password"): payload["password"] = conf.password else: payload["password"] = getpass().strip() resp = c.post(url, data=payload) if resp.history: break else: if not cnt: print "Incorrect Username or Passowrd!" sys.exit(1) else: print "Sorry, incorrect Username or Password." print "<== Signed in." payload = {"authorize": "Authorize", "embed": "false"} payload["oauth_token"] = token["oauth_token"] payload["oauth_callback"] = conf.url resp = c.post(url, data=payload, allow_redirects=False) return client.get_access_token( token["oauth_token"], token["oauth_token_secret"], resp.headers["location"].split("?")[1].split("&")[1].split("=")[1], )
def get_auth_token(): """ Run through the Evernote OAuth procedure :returns: User token string """ # Create an HTTP server on a spare port httpd = MininoteHTTPServer(('127.0.0.1', 0), MininoteHTTPRequestHandler) callbackurl = urljoin("http://{}:{}".format(*httpd.server_address), RETURN_PATH) client = EvernoteClient(consumer_key=EVERNOTE_CONSUMER_KEY, consumer_secret=EVERNOTE_CONSUMER_SECRET, sandbox=DEVELOPMENT_MODE) request_token = client.get_request_token(callbackurl) authorize_url = client.get_authorize_url(request_token) print 'Please login at the following url:\n{}'.format(authorize_url) # Open browser to auth page SilentWebbrowser(authorize_url).start() # Wait until browser is redirected httpd.server_activate() while httpd.auth_path is None: httpd.handle_request() httpd.server_close() def parse_query_string(authorize_url): query_params = urlparse(authorize_url).query return dict(kv.split('=') for kv in query_params.split('&')) vals = parse_query_string(httpd.auth_path) if 'oauth_verifier' not in vals: raise OAuthError('There was an error logging in. Please try again.') return client.get_access_token(request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier'])
def auth(): """Takes a callback for Evernote's OAuth process Redirect to main after auth token is retrived/stored in session""" # Check to make sure the user approved the appliction # (oauth_verifier will not be present if they declined) if "oauth_verifier" in request.args: # Setup client client = EvernoteClient( consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, sandbox=sandbox ) # Get access token try: auth_token = client.get_access_token( session['oauth_token'], session['oauth_token_secret'], request.args['oauth_verifier'] ) except: # Display anerror message to the user if unable to # authorize Evernote account access error_message = "OAuth Error with application '%s'" % CONSUMER_KEY return render_template("error.html", error_message=error_message) # Attach the user's access token to the session session["access_token"] = auth_token # Redirect to main return redirect(url_for("main")) # Display an error to the user when the user doesn't grant access # of the application to access their Evernote account else: error_message = "OAuth Error:\ Please approve access to the appliction %s" % CONSUMER_KEY return render_template("error.html", error_message=error_message)
def evernote_auth(client_id, client_secret, storage, sandbox=False): credentials = storage.get() if credentials is None or credentials.invalid: host = 'localhost' port = 9343 client = EvernoteClient( consumer_key=client_id, consumer_secret=client_secret, sandbox=sandbox ) request_token = client.get_request_token('http://{}:{}/'.format(host, port)) authorize_url = client.get_authorize_url(request_token) print 'Go to the following link in your browser:' print print ' ' + authorize_url print http = tools.ClientRedirectServer((host, port), tools.ClientRedirectHandler) http.handle_request() if 'oauth_verifier' not in http.query_params: print "Bad Evernote Oauth, no verifier:{}".format(http.query_params) return access_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], http.query_params['oauth_verifier'] ) token_uri = 'https://{}evernote.com/oauth'.format('sandbox.' if sandbox else '') credentials = OAuth2Credentials( access_token, client_id, client_secret, refresh_token=request_token['oauth_token'], # not really token_expiry=datetime.now() - timedelta(days=-365), token_uri=token_uri, user_agent='evernote.basic' ) storage.put(credentials) return credentials
print "Paste the URL after login here:" authurl = raw_input() ## # Parse the URL to get the OAuth verifier ## vals = parse_query_string(authurl) ## # Use the OAuth verifier and the values from request_token # to built the request for our authentication token, then # ask for it. ## auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier'] ) print("token is:" + auth_token) ## # Create a new EvernoteClient instance with our auth # token. ## client = EvernoteClient(token=auth_token,sandbox=SANDBOX) ## # Test the auth token... ## userStore = client.get_user_store()
def get_access_token(self, api_key, api_secret, oauth_token, oauth_token_secret, oauth_verifier): sdk = EvernoteSdk(consumer_key=api_key, consumer_secret=api_secret, sandbox=self.sandbox) return sdk.get_access_token(oauth_token, oauth_token_secret, oauth_verifier)
def authenticate( self): """ *authenticate* **Key Arguments:** # - **Return:** - None .. todo:: - @review: when complete, clean authenticate method - @review: when complete add logging """ self.log.info('starting the ``authenticate`` method') # Python OAuth example import evernote.edam.userstore.constants as UserStoreConstants import evernote.edam.type.ttypes as Types ## # Helper function to turn query string parameters into a # Python dictionary ## def parse_query_string(authorize_url): uargs = authorize_url.split('?') vals = {} if len(uargs) == 1: raise Exception('Invalid Authorization URL') for pair in uargs[1].split('&'): key, value = pair.split('=', 1) vals[key] = value return vals ## # Create an instance of EvernoteClient using your API # key (consumer key and consumer secret) ## client = EvernoteClient( consumer_key=self.settings["evernote"]["consumer_key"], consumer_secret=self.settings["evernote"]["consumer_secret"], sandbox=False ) ## # Provide the URL where the Evernote Cloud API should # redirect the user after the request token has been # generated. In this example, localhost is used; note # that in this example, we're copying the URLs manually # and that, in production, this URL will need to # automatically parse the response and send the user # to the next step in the flow. ## request_token = client.get_request_token('http://localhost') print request_token ## # Prompt the user to open the request URL in their browser ## print "Paste this URL in your browser and login" print print '\t' + client.get_authorize_url(request_token) print print '-------' ## # Have the user paste the resulting URL so we can pull it # apart ## print "Paste the URL after login here:" authurl = raw_input() ## # Parse the URL to get the OAuth verifier ## vals = parse_query_string(authurl) ## # Use the OAuth verifier and the values from request_token # to built the request for our authentication token, then # ask for it. ## print request_token['oauth_token'] print request_token['oauth_token_secret'] print vals['oauth_verifier'] auth_token = client.get_access_token( request_token['oauth_token'], request_token['oauth_token_secret'], vals['oauth_verifier'] ) print auth_token ## # Create a new EvernoteClient instance with our auth # token. ## client = EvernoteClient( token=auth_token, sandbox=False ) ## # Test the auth token... ## userStore = client.get_user_store() user = userStore.getUser() ## # If our username prints, it worked. ## print "Authorised under " + user.username print "Please add these to the evernote section in your settings file ..." print "auth_token: " + auth_token self.log.info('completed the ``authenticate`` method') return None
print "Please complete the following steps to continue: " print "1. Go to: %s" % auth_url print "2. Grant access to your application" print "3. Inspect at the URL you are directed to" print "4. Find the code in between '&oauth_verifier=' and '&sandbox_lnb'" print "5. Enter that code (the OAuth verifier) below: " verifier = raw_input("OAuth verifier: ") auth_token = None # Get access token while not auth_token: try: auth_token = client.get_access_token( temp_token, temp_secret, verifier ) except: print "Incorrect OAuth verifier." print "Try again or press control+Z to exit." verifier = raw_input("OAuthVerifier: ") user_store = client.get_user_store() version_ok = user_store.checkVersion( "Evernote EDAMTest (Python)", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR ) print "Is my Evernote API version up to date? ", str(version_ok)
def get_access_token(api_key, api_secret, sandbox=False, **oauth_kwargs): sdk = EvernoteSdk(consumer_key=api_key, consumer_secret=api_secret, sandbox=sandbox) return sdk.get_access_token(oauth_kwargs["token"], oauth_kwargs["secret"], oauth_kwargs["verifier"])