def reg_twitter(self,
token_key=None,
token_secret=None,
token_pin=None):
import autosubliminal.notifiers.twitter as twitter_notifier
if not token_key and not token_secret:
# Getting request token
oauth_client = OAuth1Session(
client_key=twitter_notifier.CONSUMER_KEY,
client_secret=twitter_notifier.CONSUMER_SECRET)
try:
response = oauth_client.fetch_request_token(
twitter_notifier.REQUEST_TOKEN_URL)
except Exception as e:
message = 'Something went wrong.../n' + e.message
return PageTemplate(
filename='/general/message.mako').render(
message=message)
# Authorize
url = oauth_client.authorization_url(
twitter_notifier.AUTHORIZATION_URL)
token_key = response.get('oauth_token')
token_secret = response.get('oauth_token_secret')
return PageTemplate(
filename='/config/config-regtwitter.mako').render(
url=url,
token_key=token_key,
token_secret=token_secret)
if token_key and token_secret and token_pin:
# Getting access token
oauth_client = OAuth1Session(
client_key=twitter_notifier.CONSUMER_KEY,
client_secret=twitter_notifier.CONSUMER_SECRET,
resource_owner_key=token_key,
resource_owner_secret=token_secret,
verifier=token_pin)
try:
response = oauth_client.fetch_access_token(
twitter_notifier.ACCESS_TOKEN_URL)
except Exception as e:
message = 'Something went wrong.../n' + e.message
return PageTemplate(
filename='/general/message.mako').render(
message=message)
# Store access token
autosubliminal.TWITTERKEY = response.get('oauth_token')
autosubliminal.TWITTERSECRET = response.get(
'oauth_token_secret')
# Render template
message = 'Twitter is now set up, remember to save your config and remember to test twitter!' \
'<br><a href="' + autosubliminal.WEBROOT + '/config/notification">Return</a>'
return PageTemplate(filename='/general/message.mako').render(
message=message)
def authenticate(consumer_key, consumer_secret):
"""
Authenticate against the Twitter API
"""
# This implements the so called PIN-Based OAuth flow as described here:
# https://developer.twitter.com/en/docs/basics/authentication/overview/pin-based-oauth
if credentials.exists():
click.confirm(
"This will overwrite existing credentials, are you sure?",
abort=True)
# Step 1: fetch a request token
oauth = OAuth1Session(consumer_key, consumer_secret)
try:
request_token_response = oauth.fetch_request_token(
"https://api.twitter.com/oauth/request_token?oauth_callback=oob")
except TokenRequestDenied:
raise click.ClickException(
"Invalid consumer secret/consumer key combination")
# Step 2: get an authorization url and ask user to enter the PIN
authorization_url = oauth.authorization_url(
"https://api.twitter.com/oauth/authorize")
pin = input("In order to authenticate, go to the following URL, "
"authorize the app and copy the PIN:\n"
f"{authorization_url}\n"
"Enter PIN: ")
# Step 3: get an access token using the PIN
oauth = OAuth1Session(
client_key=consumer_key,
client_secret=consumer_secret,
resource_owner_key=request_token_response["oauth_token"],
resource_owner_secret=request_token_response["oauth_token_secret"],
verifier=pin,
)
try:
access_token_response = oauth.fetch_access_token(
"https://api.twitter.com/oauth/access_token")
except TokenRequestDenied:
raise click.ClickException("Entered PIN is invalid")
# Create new OAuth1 instance that can be used by the `requests` library for
# authenticating requests and store it for later use.
credentials.save(
OAuth1(
client_key=consumer_key,
client_secret=consumer_secret,
resource_owner_key=access_token_response["oauth_token"],
resource_owner_secret=access_token_response["oauth_token_secret"],
))
print("Authentication saved, bieberhose is ready to go! 🚀")
def continue_flow(request, redirect_response):
"""
Continues the oauth flow. This will fetch the login tokens and login the user if all information were given.
Otherwise the registration modal will be displayed.
:param request:
:param redirect_response:
:return:
"""
client_id = os.environ.get('OAUTH_TWITTER_CLIENTID', None)
client_secret = os.environ.get('OAUTH_TWITTER_CLIENTKEY', None)
LOG.debug("Read OAuth id/secret: none? %s/%s", client_id is None,
client_secret is None)
pincode = redirect_response.split('oauth_verifier=')[1]
access_token_url = 'https://api.twitter.com/oauth/access_token'
oauth_token = request.session['twitter_oauth_token']
oauth_token_secret = request.session['twitter_oauth_token_secret']
oauth_client = OAuth1Session(client_id,
client_secret=client_secret,
resource_owner_key=oauth_token,
resource_owner_secret=oauth_token_secret,
verifier=pincode)
resp = oauth_client.fetch_access_token(access_token_url)
user_data = {'id': resp['id'], 'nickname': resp['screen_name']}
missing_data = [key for key in oauth_values if len(user_data[key]) == 0]
return get_oauth_ret_dict(user_data=user_data, missing_data=missing_data)
def start_flow(**kwargs):
"""
Starts the oauth flow. This will return a dict which causes a redirect to the providers page.
:param kwargs: should have a redirect_uri and a request
:return:
"""
redirect_uri = kwargs.get('redirect_uri')
request = kwargs.get('request')
LOG.debug("Read OAuth id/secret: none? %s/%s", CLIENT_ID is None,
CLIENT_SECRET is None)
request_token_url = 'https://api.twitter.com/oauth/request_token'
authorization_url = 'https://api.twitter.com/oauth/authorize'
oauth_client = OAuth1Session(CLIENT_ID,
client_secret=CLIENT_SECRET,
callback_uri=redirect_uri)
resp = oauth_client.fetch_request_token(request_token_url)
url = oauth_client.authorization_url(authorization_url)
request.session['twitter_oauth_token'] = resp.get('oauth_token')
request.session['twitter_oauth_token_secret'] = resp.get(
'oauth_token_secret')
LOG.debug("Please go to %s and authorize access", authorization_url)
return {'authorization_url': url, 'error': ''}
def __init__(self,
consumer_key,
consumer_secret,
oauth_token=None,
mobile=False):
self._consumer_key = consumer_key
self._consumer_secret = consumer_secret
self._oauth_token = oauth_token
self._session = OAuth1Session(consumer_key, consumer_secret)
self._session.mount('http://', HTTPAdapter(max_retries=5))
self._session.mount('https://', HTTPAdapter(max_retries=5))
if oauth_token:
self._session._populate_attributes(oauth_token)
self.request_token = None
self._oauth_type = None
self.request_token_url = 'http://fanfou.com/oauth/request_token'
self.access_token_url = 'http://fanfou.com/oauth/access_token'
self.authorize_url = 'http://m.fanfou.com/oauth/authorize' \
if mobile else 'http://fanfou.com/oauth/authorize'
self._me = None
self.draft_box = []
self.mentions = Timeline(self, None, 'statuses/mentions')
self.replies = Timeline(self, None, 'statuses/replies')
self.public_timeline = Timeline(self, None, 'statuses/public_timeline')
def continue_flow(request, redirect_response):
"""
:param request:
:param redirect_response:
:return:
"""
client_id = os.environ.get('OAUTH_TWITTER_CLIENTID', None)
client_secret = os.environ.get('OAUTH_TWITTER_CLIENTKEY', None)
logger(
'Twitter OAuth',
'Read OAuth id/secret: none? {}'.format(client_id is None,
client_secret is None))
pincode = redirect_response.split('oauth_verifier=')[1]
access_token_url = 'https://api.twitter.com/oauth/access_token'
oauth_token = request.session['twitter_oauth_token']
oauth_token_secret = request.session['twitter_oauth_token_secret']
oauth_client = OAuth1Session(client_id,
client_secret=client_secret,
resource_owner_key=oauth_token,
resource_owner_secret=oauth_token_secret,
verifier=pincode)
resp = oauth_client.fetch_access_token(access_token_url)
user_data = {'id': resp['id'], 'nickname': resp['screen_name']}
missing_data = [key for key in oauth_values if len(user_data[key]) == 0]
return {'user': user_data, 'missing': missing_data, 'error': ''}
def start_flow(request, redirect_uri):
"""
:param request:
:param redirect_uri:
:return:
"""
client_id = os.environ.get('OAUTH_TWITTER_CLIENTID', None)
client_secret = os.environ.get('OAUTH_TWITTER_CLIENTKEY', None)
logger(
'Twitter OAuth',
'Read OAuth id/secret: none? {}'.format(client_id is None,
client_secret is None))
request_token_url = 'https://api.twitter.com/oauth/request_token'
authorization_url = 'https://api.twitter.com/oauth/authorize'
oauth_client = OAuth1Session(client_id,
client_secret=client_secret,
callback_uri=redirect_uri)
resp = oauth_client.fetch_request_token(request_token_url)
url = oauth_client.authorization_url(authorization_url)
request.session['twitter_oauth_token'] = resp.get('oauth_token')
request.session['twitter_oauth_token_secret'] = resp.get(
'oauth_token_secret')
logger('Twitter OAuth',
'Please go to {} and authorize access'.format(authorization_url))
return {'authorization_url': url, 'error': ''}
def main(args):
"""
main
"""
ret = 0
try:
oauth = OAuth1Session(CONSUMER_KEY,
client_secret=CONSUMER_SECRET,
callback_uri=CALLBACK_URI)
fetch_response = oauth.fetch_request_token(REQUEST_TOKEN_URL)
resource_owner_key = fetch_response.get('oauth_token')
resource_owner_secret = fetch_response.get('oauth_token_secret')
#print('resource_owner_key', resource_owner_key)
#print('resource_owner_secret', resource_owner_secret)
auth_url = oauth.authorization_url(AUTHORIZE_URL)
print('enter this auth url into browser.', auth_url)
print('and get the verifier(from html source).')
print('')
verifier = input('input verifier:')
oauth = OAuth1Session(CONSUMER_KEY,
client_secret=CONSUMER_SECRET,
resource_owner_key=resource_owner_key,
resource_owner_secret=resource_owner_secret)
fetch_response = oauth.fetch_access_token(ACCESS_TOKEN_URL,
verifier=verifier)
resource_owner_key = fetch_response.get('oauth_token')
resource_owner_secret = fetch_response.get('oauth_token_secret')
print('access_token', resource_owner_key)
print('access_secret', resource_owner_secret)
except Exception as e:
print(e.__class__.__name__)
print(e)
ret = 1
return ret
def __init__(self, cfg):
self.cfg = cfg
self.api_url = cfg.api_url
self.session = OAuth1Session(self.cfg.consumer_key,
self.cfg.consumer_secret)
self.access_token = self.cfg.user.get('access_token')
if not self.access_token:
if self.cfg.xauth:
self.access_token = self.xauth()
else:
self.access_token = self.oauth()
self.session._populate_attributes(self.access_token)
self.cfg.user['access_token'] = self.access_token
def xauth(self, username, password):
import oauthlib.oauth1.rfc5849.utils
# patch to allow x_auth_* params
oauthlib.oauth1.rfc5849.utils.filter_oauth_params = lambda _: _
# noinspection PyProtectedMember
client = self._session._client.client
class OAuth1Client(oauthlib.oauth1.rfc5849.Client):
def get_oauth_params(self, request):
params = super(OAuth1Client, self).get_oauth_params(request)
args = [
('x_auth_username', username),
('x_auth_password', password),
('x_auth_mode', 'client_auth')
]
params += args
return params
sess = OAuth1Session(client.client_key, client.client_secret, client_class=OAuth1Client)
token = sess.fetch_access_token(self.access_token_url, verifier='x')
self._oauth_token = token
self._session._populate_attributes(token)
return token
def xauth(self):
# 1. form base request args
# 2. generate signature, add to base args
# 3. generate Authorization header from base args
username = get_input(cstring('[-]请输入用户名或邮箱>', 'cyan'))
password = getpass.getpass(cstring('[-]请输入密码>', 'cyan'))
# 这些实际上并不是url params，但是他们与其他url params一样参与签名，最终成为Authorization header的值
args = [('x_auth_username', username), ('x_auth_password', password),
('x_auth_mode', 'client_auth')]
class OAuth1ClientPatch(OAuth1Client):
"""Patch oauthlib.oauth1.Client for xauth"""
def get_oauth_params(self, request):
params = super().get_oauth_params(request)
params.extend(args)
return params
sess = OAuth1Session(self.cfg.consumer_key,
self.cfg.consumer_secret,
client_class=OAuth1ClientPatch)
access_token = sess.fetch_access_token(self.cfg.access_token_url,
verifier='123')
return access_token
print(str(index) + ' : ' + token.get('user') + ' (created: ' + token.get('timestamp') + ')')
print('a : add a new token')
print('q : quit program')
choice = input('Your choice?: ')
if choice == 'q':
sys.exit()
chosen_token = {}
client_key = chosen_credentials.get('client_key')
client_secret = chosen_credentials.get('client_secret')
if choice == 'a':
print('Adding a token...')
print('Step 0: access API catalog (using only client security context)')
oauth_session = OAuth1Session(client_key, client_secret=client_secret)
url = base_url + '/'
r = oauth_session.get(url, headers=DEFAULT_JSON_HEADER)
response = r.json()
print(json.dumps(response, indent=4, sort_keys=True))
request_token_url = extract_link(response, 'oauthRequestToken')
authorization_url = extract_link(response, 'oauthAuthorizeRequestToken')
#authorization_url = 'https://my.deere.com/consentToUseOfData'
access_token_url = extract_link(response, 'oauthAccessToken')
wait = input('Enter to continue...')
print()
print('Step 1: use urls from catalog to fetch a request token (using same client security context)')
oauth_session = OAuth1Session(client_key, client_secret=client_secret, callback_uri=callback_uri)
r = oauth_session.fetch_request_token(url=request_token_url)
print(json.dumps(r, indent=4, sort_keys=True))
def __init__(self, consumer_key, consumer_secret=None):
self._oauth = OAuth(client_key=consumer_key,
client_secret=consumer_secret)
class Client:
def __init__(self, consumer_key, consumer_secret=None):
self._oauth = OAuth(client_key=consumer_key,
client_secret=consumer_secret)
def search(self,
query: str = None,
category: Category = None,
type: str = None,
genre: str = None,
artist: str = None,
year_min: int = None,
year_max: int = None,
size_min: int = None,
size_max: int = None,
sort: SortType = None,
sort_order: SortOrder = SortOrder.ASC) -> [File]:
"""
Search files
:param query: The search string (from 1 to 200 symbols).
:param category: The category of the files to search.
:param type: Type of the file to search (e.g. pdf, mp3, jpg, ...).
:param genre: Filter by music genre.
:param artist: Filter by artist name.
:param year_min: Filter by minimum year of upload.
:param year_max: Filter by maximum year of upload.
:param size_min: Filter by minimum size in bytes.
:param size_max: Filter by maximum size in bytes.
:param sort: Type for the sorting.
:param sort_order: Order of the sorting.
:return: Return a list of the fetched files.
"""
params = {}
def add_param(key, value):
if value is not None:
params[key] = value
add_param('query', query)
add_param('type', type)
add_param('genre', genre)
add_param('artist', artist)
add_param('year_min', year_min)
add_param('year_max', year_max)
add_param('size_min', size_min)
add_param('size_max', size_max)
# Convert the category into a number
if category is not None:
params['category'] = category._value_
# Format the sort parameter
if sort is not None:
params['sort'] = '%s,%s' % (sort._value_, sort_order._value_)
logger.info('Search with params: %s' % params)
response = self._get_json(url='https://search.4shared.com/v1_2/files',
params=params)
files = response['files']
return [File(json) for json in files]
def download(self, id: str) -> bytes:
url = ' https://api.4shared.com/v1_2/files/%s/download' % id
response = self._oauth.get(url)
return response.content
def _get_json(self, url, **kwargs):
return self._request_json('GET', url, **kwargs)
def _request_json(self, method, url, **kwargs):
request = self._oauth.request(method,
url,
headers={'Accept': 'application/json'},
**kwargs)
return request.json()
import pickle
from requests_oauthlib.oauth1_session import OAuth1Session
import json
from numpy import random
DEFAULT_JSON_HEADER = {'Accept': 'application/vnd.deere.axiom.v3+json'}
base_url = 'https://apicert.soa-proxy.deere.com/platform'
client_key = 'johndeere-54ET8agkbEm5s5WT83Kfyx57'
client_secret = 'af433adb114ea5539aca09cc0c09f53cb52a2237'
oauth_session = OAuth1Session(
client_key,
client_secret=client_secret,
resource_owner_key='c2eb1ca4-dc44-4d92-adcd-d0888359af78',
resource_owner_secret=
'Xi42JPNcK5xKoxsiv2MuK5Wr/TPkGRzmu/oAlCIOk19VBdwP8RzE+ZzAms0dFL7FS96m+qX7ag2Z7WuO24W01bxdZkHaiWf24lNR+BaQwu4='
)
r = oauth_session.get(base_url + '/', headers=DEFAULT_JSON_HEADER)
def corn_or_soy():
if random.randint(2) == 0:
return "CORN"
else:
return "SOY"
def my_handle_endpoint(this_choice):
_response = None
_url = this_choice
if _url is not None:
