def main():
url = urlparse.urlparse(sys.argv[1])
# Nevermind that the query can have repeated keys.
parameters = dict(urlparse.parse_qsl(url.query))
password_file = open(os.path.join(user.home, '.oget'))
lines = [line.strip() for line in password_file.readlines()]
if len(lines) == 4:
cons_key, cons_key_secret, username, password = lines
access_token = None
else:
cons_key, cons_key_secret, username, password, token, secret = lines
access_token = oauth.OAuthToken(token, secret)
consumer = oauth.OAuthConsumer(cons_key, cons_key_secret)
if not access_token:
oauth_request = create_signed_oauth_request(username, password,
consumer)
connection = httplib.HTTPConnection(SERVER)
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
connection.request(oauth_request.http_method,
AUTHEXCHANGE_URL,
body=oauth_request.to_postdata(),
headers=headers)
auth_response = connection.getresponse().read()
token = parse_auth_response(auth_response)
access_token = oauth.OAuthToken(*token)
open(os.path.join(user.home, '.oget'), 'w').write('\n'.join(
(cons_key, cons_key_secret, username, password, token[0],
token[1])))
oauth_request = oauth.OAuthRequest.from_consumer_and_token(
consumer,
access_token,
http_method='POST',
http_url=url.geturl(),
parameters=parameters)
oauth_request.sign_request(SIGNATURE_METHOD, consumer, access_token)
connection = httplib.HTTPConnection(SERVER)
connection.request(oauth_request.http_method,
oauth_request.to_url(),
body=oauth_request.to_postdata(),
headers=CONTENT_TYPE_HEADER)
print connection.getresponse().read()
def new_session(self,
request_key=None,
request_secret=None,
access_key=None,
access_secret=None):
if request_secret and request_key:
request_token = oauth.OAuthToken(request_key, request_secret)
else:
request_token = None
if access_secret and access_key:
access_token = oauth.OAuthToken(access_key, access_secret)
else:
access_token = None
return MeetupOAuthSession(self.consumer, request_token, access_token)
def __init__(self,
key=None,
secret=None,
callback=None,
access_token_key=None,
access_token_secret=None,
request_token_key=None,
request_token_secret=None):
self.key = key or method_call.API_KEY
self.secret = secret or method_call.API_SECRET
if self.key is None or self.secret is None:
raise ValueError("API keys have not been set.")
if callback is None:
callback = "http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=%s" % self.key
params = {
'oauth_timestamp': str(int(time.time())),
'oauth_signature_method': "HMAC-SHA1",
'oauth_version': "1.0",
'oauth_callback': callback,
'oauth_nonce': oauth.generate_nonce(),
'oauth_consumer_key': self.key
}
self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
if (access_token_key is None) and (request_token_key is None):
req = oauth.OAuthRequest(http_method="GET",
http_url=TOKEN_REQUEST_URL,
parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
resp = urllib2.urlopen(req.to_url())
request_token = dict(urlparse.parse_qsl(resp.read()))
self.request_token = oauth.OAuthToken(
request_token['oauth_token'],
request_token['oauth_token_secret'])
self.access_token = None
elif request_token_key is not None:
self.access_token = None
self.request_token = oauth.OAuthToken(request_token_key,
request_token_secret)
else:
self.request_token = None
self.access_token = oauth.OAuthToken(access_token_key,
access_token_secret)
def set_verifier(self, oauth_verifier):
if self.request_token is None:
raise AuthHandlerError(
"Request token is not defined. This ususally means that the access token has been loaded from a file."
)
self.request_token.set_verifier(oauth_verifier)
access_token_parms = {
'oauth_consumer_key': self.key,
'oauth_nonce': oauth.generate_nonce(),
'oauth_signature_method': "HMAC-SHA1",
'oauth_timestamp': str(int(time.time())),
'oauth_token': self.request_token.key,
'oauth_verifier': self.request_token.verifier
}
req = oauth.OAuthRequest(http_method="GET",
http_url=ACCESS_TOKEN_URL,
parameters=access_token_parms)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.request_token)
resp = urllib2.urlopen(req.to_url())
access_token_resp = dict(urlparse.parse_qsl(resp.read()))
self.access_token = oauth.OAuthToken(
access_token_resp["oauth_token"],
access_token_resp["oauth_token_secret"])
def augment(url, parameters, credentials, http_method='GET'):
"""
Create a URL for HTTP request with authentication
information. These are added as extra parameters.
"""
# Create an object with the api key and secret key as attributes `key` and `secret`:
consumer = oauth.OAuthConsumer(credentials['api_key'],
credentials['api_secret_key'])
# Create an object with the token and token secret as attributes; this object has to/from string methods:
token = oauth.OAuthToken(credentials['access_token'],
credentials['access_token_secret'])
# Create an object with all the provided information plus OAuth version, timestamp and random number:
oauth_request = oauth.OAuthRequest.from_consumer_and_token(
consumer,
token=token,
http_method=http_method,
http_url=url,
parameters=parameters)
# Create the attribute 'oauth_signature' in the object; this attribute is a authentication signature built from my secret key and the full message to be sent:
oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
consumer, token)
return oauth_request.to_url()
def augment(url, parameters):
secrets = hidden.oauth()
consumer = oauth.OAuthConsumer(secrets['consumer_key'], secrets['consumer_secret'])
token = oauth.OAuthToken(secrets['token_key'], secrets['token_secret'])
oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer, token = token, http_method='GET', http_url = url, parameters = parameters)
oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, token)
return oauth_request.to_url()
def doRequest(method, params):
global config
consumer = oauth.OAuthConsumer(PUBLIC_KEY, PRIVATE_KEY)
token = oauth.OAuthToken(config['telldus']['token'],
config['telldus']['tokenSecret'])
oauth_request = oauth.OAuthRequest.from_consumer_and_token(
consumer,
token=token,
http_method='GET',
http_url="http://api.telldus.com/json/" + method,
parameters=params)
oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
consumer, token)
headers = oauth_request.to_header()
headers['Content-Type'] = 'application/x-www-form-urlencoded'
conn = httplib.HTTPConnection("api.telldus.com:80")
conn.request('GET',
"/json/" + method + "?" +
urllib.urlencode(params, True).replace('+', '%20'),
headers=headers)
response = conn.getresponse()
return json.load(response)
def modifyQueueDisc(self, ID, method, position=None):
accessToken = self.accessToken
parameters = {}
#to add, use Post, to remove use Delete
parameters['method'] = method
if (position):
parameters['position'] = str(position)
if (method == "post"):
parameters[
'title_ref'] = 'http://api-public.netflix.com/catalog/titles/movies/' + str(
ID)
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
if (method == "post"):
requestUrl = '/users/' + accessToken.key + '/queues/disc/available'
else:
requestUrl = '/users/' + accessToken.key + '/queues/disc/available/' + str(
ID)
print "------- REQUESTED URL IS: " + requestUrl
try:
info = simplejson.loads(
self.client._getResource(requestUrl,
parameters=parameters,
token=accessToken), 'latin-1')
except:
return {}
return info
def getSimilarMovies(self, ID, maxResults=None):
accessToken = self.accessToken
parameters = {}
if maxResults:
parameters['max_results'] = maxResults
parameters['v'] = str('2.0')
parameters[
'filters'] = 'http://api-public.netflix.com/categories/title_formats/instant'
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
requestUrl = '/catalog/titles/movies/' + str(ID) + '/similars'
print requestUrl
try:
info = simplejson.loads(
self.client._getResource(requestUrl,
parameters=parameters,
token=accessToken), 'latin-1')
except:
return {}
return info
def searchTitles(self,
term,
queue,
startIndex=None,
maxResults=None,
caUser=None):
accessToken = self.accessToken
requestUrl = '/catalog/titles'
parameters = {'term': term}
if startIndex:
parameters['start_index'] = startIndex
if maxResults:
parameters['max_results'] = maxResults
if caUser:
if (caUser == True):
parameters['country'] = "ca"
parameters['v'] = str('2.0')
parameters[
'filters'] = 'http://api-public.netflix.com/categories/title_formats/' + queue
parameters[
'expand'] = '@title,@synopsis,@directors,@formats,@episodes,@short_synopsis'
parameters['output'] = 'json'
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
info = simplejson.loads(
self.client._getResource(requestUrl,
parameters=parameters,
token=accessToken), 'latin-1')
return info
def removeTitle(self, id, queueType='disc'):
accessToken = self.user.accessToken
entryID = None
parameters = {}
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
# First, we gotta find the entry to delete
queueparams = {'max_results': 500}
requestUrl = '/users/%s/queues/disc' % (accessToken.key)
response = self.client._getResource(requestUrl,
token=accessToken,
parameters=queueparams)
print "Response is " + response
response = simplejson.loads(response, 'latin-1')
titles = response["queue"]["queue_item"]
for disc in titles:
discID = os.path.basename(urlparse(disc['id']).path)
if discID == id:
entryID = disc['id']
if not entryID:
return
firstResponse = self.client._getResource(entryID,
token=accessToken,
parameters=parameters)
response = self.client._deleteResource(entryID, token=accessToken)
return response
def getRentalHistoryv1(self,
historyType=None,
startIndex=None,
maxResults=None,
updatedMin=None):
accessToken = self.accessToken
parameters = {}
if startIndex:
parameters['start_index'] = startIndex
if maxResults:
parameters['max_results'] = maxResults
if updatedMin:
parameters['updated_min'] = updatedMin
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
if not historyType:
requestUrl = '/users/%s/rental_history' % (accessToken.key)
else:
requestUrl = '/users/%s/rental_history/%s' % (accessToken.key,
historyType)
try:
info = simplejson.loads(
self.client._getResource(requestUrl,
parameters=parameters,
token=accessToken), 'latin-1')
except:
return {}
return info
def set_token(self, access_token, access_token_secret):
"""Attach an access token to the DropboxSession.
Note that the access 'token' is made up of both a token string
and a secret string.
"""
self.token = oauth.OAuthToken(access_token, access_token_secret)
def getSeries(self, curTID, curSeasonID, queue, startIndex=None,maxResults=None,caUser=None):
accessToken=self.accessToken
parameters = {}
requestUrl1 = '/catalog/titles/series/'+curTID
requestUrl2 = '/seasons/'+curSeasonID
if(not curSeasonID == ""):
requestUrl = requestUrl1 + requestUrl2
else:
requestUrl = requestUrl1
if startIndex:
parameters['start_index'] = startIndex
if maxResults:
parameters['max_results'] = maxResults
if caUser:
if (caUser == True):
parameters['country'] = "ca"
parameters['v'] = str('2.0')
parameters['filters'] = 'http://api.netflix.com/categories/title_formats/' + queue
parameters['expand'] = '@title,@synopsis,@directors,@formats,@episodes,@short_synopsis'
parameters['output'] = 'json'
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'], accessToken['secret'] )
info = simplejson.loads( self.client._getResource(requestUrl, parameters=parameters, token=accessToken ))
if re.search(r"Invalid Series", str(info), re.DOTALL | re.IGNORECASE | re.MULTILINE):
#reset url to programs
requestUrl = '/catalog/titles/programs/'+curTID
info = simplejson.loads( self.client._getResource(requestUrl, parameters=parameters, token=accessToken ))
if re.search(r"Resource Not Found", str(info), re.DOTALL | re.IGNORECASE | re.MULTILINE):
#reset url to movies
requestUrl = '/catalog/titles/movies/'+curTID
info = simplejson.loads( self.client._getResource(requestUrl, parameters=parameters, token=accessToken ))
return info
def getAccessToken():
global config
consumer = oauth.OAuthConsumer(PUBLIC_KEY, PRIVATE_KEY)
token = oauth.OAuthToken(config['telldus']['requestToken'],
config['telldus']['requestTokenSecret'])
request = oauth.OAuthRequest.from_consumer_and_token(
consumer,
token=token,
http_method='GET',
http_url='http://api.telldus.com/oauth/accessToken')
request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer,
token)
conn = httplib.HTTPConnection('api.telldus.com:80')
conn.request(request.http_method,
request.to_url(),
headers=request.to_header())
resp = conn.getresponse()
if resp.status != 200:
print('Error retrieving access token, the server replied:\n%s' %
resp.read())
return
token = oauth.OAuthToken.from_string(resp.read())
config['telldus']['requestToken'] = None
config['telldus']['requestTokenSecret'] = None
config['telldus']['token'] = str(token.key)
config['telldus']['tokenSecret'] = str(token.secret)
print('Authentication successful, you can now use tdtool')
saveConfig()
def getAtHomeList(self,historyType=None,startIndex=None,maxResults=None,updatedMin=None):
accessToken=self.accessToken
parameters = {}
if startIndex:
parameters['start_index'] = startIndex
if maxResults:
parameters['max_results'] = maxResults
if updatedMin:
parameters['updated_min'] = updatedMin
parameters['v'] = str('2.0')
parameters['filters'] = 'http://api.netflix.com/categories/title_formats/instant'
parameters['expand'] = '@title,@synopsis,@directors,@formats,@episodes,@short_synopsis'
parameters['output'] = 'json'
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(
accessToken['key'],
accessToken['secret'] )
#if not historyType:
requestUrl = '/users/%s/at_home' % (accessToken.key)
#else:
# requestUrl = '/users/%s/queues/instant/available/%s' % (accessToken.key,historyType)
try:
info = simplejson.loads( self.client._getResource(requestUrl, parameters=parameters, token=accessToken ) )
except:
return {}
return info
def getRecommendedQueue(self,startIndex=None,maxResults=None,updatedMin=None,caUser=None):
accessToken=self.accessToken
parameters = {}
if startIndex:
parameters['start_index'] = startIndex
if maxResults:
parameters['max_results'] = maxResults
if updatedMin:
parameters['updated_min'] = updatedMin
if caUser:
if (caUser == True):
parameters['country'] = "ca"
parameters['v'] = str('2.0')
parameters['filters'] = 'http://api.netflix.com/categories/title_formats/instant'
parameters['expand'] = '@title,@cast,@synopsis,@directors,@formats,@episodes,@short_synopsis'
parameters['output'] = 'json'
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'], accessToken['secret'] )
requestUrl = '/users/%s/recommendations' % (accessToken.key)
try:
info = simplejson.loads( self.client._getResource(requestUrl, parameters=parameters, token=accessToken ) )
except:
return {}
return info
def __init__(self, user, client):
self.requestTokenUrl = REQUEST_TOKEN_URL
self.accessTokenUrl = ACCESS_TOKEN_URL
self.authorizationUrl = AUTHORIZATION_URL
self.accessToken = oauth.OAuthToken(user['access']['key'], user['access']['secret'] )
self.client = client
self.data = None
def getRentalHistory(self,historyType=None,startIndex=None, maxResults=None,updatedMin=None):
accessToken=self.accessToken
parameters = {}
if startIndex:
parameters['start_index'] = startIndex
if maxResults:
parameters['max_results'] = maxResults
if updatedMin:
parameters['updated_min'] = updatedMin
parameters['v'] = str('2.0')
parameters['expand'] = '@title,@synopsis,@directors,@formats,@episodes,@short_synopsis'
parameters['output'] = 'json'
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'], accessToken['secret'] )
#history type must be: NULL, shipped, returned, or watched
if not historyType:
requestUrl = '/users/%s/rental_history' % (accessToken.key)
else:
requestUrl = '/users/%s/rental_history/%s' % (accessToken.key,historyType)
try:
info = simplejson.loads( self.client._getResource(requestUrl, parameters=parameters, token=accessToken ) )
except:
return {}
return info
def set_request_token(self, request_token, request_token_secret):
"""Attach an request token to the DropboxSession.
Note that the reuest 'token' is made up of both a token string
and a secret string.
"""
self.token = oauth.OAuthToken(request_token, request_token_secret)
def addTitle(self, discInfo=[], urls=[], queueType='disc', position=None):
accessToken = self.user.accessToken
parameters = {}
if position:
parameters['position'] = position
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
requestUrl = '/users/%s/queues/disc' % (accessToken.key)
if not urls:
for disc in discInfo:
urls.append(disc['id'])
parameters['title_ref'] = ','.join(urls)
if not self.tag:
response = self.client._getResource(requestUrl, token=accessToken)
response = simplejson.loads(response, 'latin-1')
self.tag = response["queue"]["etag"]
parameters['etag'] = self.tag
response = self.client._postResource(requestUrl,
token=accessToken,
parameters=parameters)
return response
def getRatings(self, discInfo=[], urls=[]):
accessToken = self.accessToken
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'],
accessToken['secret'])
requestUrl = '/users/%s/ratings/title' % (accessToken.key)
if not urls:
if isinstance(discInfo, list):
for disc in discInfo:
urls.append(disc['id'])
else:
urls.append(discInfo['id'])
parameters = {'title_refs': ','.join(urls)}
info = simplejson.loads(
self.client._getResource(requestUrl,
parameters=parameters,
token=accessToken), 'latin-1')
ret = {}
for title in info['ratings']['ratings_item']:
ratings = {
'average': title['average_rating'],
'predicted': title['predicted_rating'],
}
try:
ratings['user'] = title['user_rating']
except:
pass
ret[title['title']['regular']] = ratings
return ret
def get_access_token(self, key=None, secret=None, token=None):
if key and secret:
token = oauth.OAuthToken(key, secret)
assert token is not None
oauth_request = oauth.OAuthRequest.from_consumer_and_token(self.consumer,
token=token, http_url=ACCESS_TOKEN_URL)
oauth_request.sign_request(signature_method, self.consumer, token)
return self.fetch_token(oauth_request)[:3]
def __init__(self, uid, key=None, secret=None):
self.uid = uid
self.key = key
self.secret = secret
self.consumer = oauth.OAuthConsumer(API_KEY, API_SECRET)
if key and secret:
self.token = oauth.OAuthToken(key, secret)
else:
self.token = None
def testBadRequestToken(self):
'''Verify that attempting to use a broken request token fails with a 401 HTTP status.'''
oaBadRequestToken = oauth.OAuthToken('qqqq', 'vvvvv')
oaBadRequestToken.set_verifier('zipf')
try:
oauth_get_access_token(self._oaConsumer, oaBadRequestToken)
except CascadeHTTPError, e:
self.assertEquals(401, e.getHTTPStatus())
def getData(self):
accessToken=self.accessToken
if not isinstance(accessToken, oauth.OAuthToken):
accessToken = oauth.OAuthToken(accessToken['key'], accessToken['secret'] )
requestUrl = '/users/%s' % (accessToken.key)
info = simplejson.loads( self.client._getResource(requestUrl, token=accessToken ) )
self.data = info['user']
return self.data
def get_access_token(self, token_, verifier_):
tokenSecret = self.restoreTokenFromKey(token_)
request_token = oauth.OAuthToken(token_, tokenSecret)
oauth_request = oauth.OAuthRequest.from_consumer_and_token(
self.consumer,
token=request_token,
verifier=verifier_,
http_url=self.client.access_token_url)
oauth_request.sign_request(self.signature_method_plaintext,
self.consumer, request_token)
return self.client.fetch_access_token(oauth_request)
def augment(url, parameters): """ This function augments the twitter url adding the authontication data necessary for the scrapping. """ secrets = Hidden.oauth() consumer = oauth.OAuthConsumer(secrets['consumer_key'], secrets['consumer_secret']) token = oauth.OAuthToken(secrets['token_key'], secrets['token_secret']) oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer, token=token, http_method='GET', http_url=url, parameters=parameters) oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, token) return oauth_request.to_url()
def aumentar(url, parametros):
credenciales = hidden.oauth()
consumidor = oauth.OAuthConsumer(credenciales['consumer_key'],
credenciales['consumer_secret'])
token = oauth.OAuthToken(credenciales['token_key'], credenciales['token_secret'])
oauth_solicitud = oauth.OAuthRequest.from_consumer_and_token(consumidor,
token=token, http_method='GET', http_url=url,
parameters=parametros)
oauth_solicitud.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
consumidor, token)
return oauth_solicitud.to_url()
def __init__(self, accessToken, accessSecret):
"""class init method
Arguments:
- `accessToken`:
- `accessSecret`:
"""
self._accessToken = oauth.OAuthToken(accessToken, accessSecret)
self._connection = httplib.HTTPConnection("%s:%d" % (SERVER, PORT))
self.signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1(
)
self.consumer = oauth.OAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET)
