def Twitter(request):
tweets = cache.get('tweets')
if not tweets:
try:
api = tweetpony.API(
consumer_key=settings.TWITTER_OAUTH['consumer_key'],
consumer_secret=settings.TWITTER_OAUTH['consumer_secret'],
access_token=settings.TWITTER_OAUTH['access_token'],
access_token_secret=settings.
TWITTER_OAUTH['access_token_secret'])
tweetRequest = api.user_timeline(count=1)
if tweetRequest:
tweets = tweetRequest
cache.set('tweets', list(tweets), timeout=3600)
except tweetpony.APIError:
tweets = None
if tweets:
tweet = tweets[0]
else:
tweet = None
return {
'twitter_tweet': tweet,
'twitter_link':
"https://twitter.com/" + settings.TWITTER_OAUTH['user'],
'twitter_user': settings.TWITTER_OAUTH['user']
}
def reset_auth_token(self):
self.api = tweetpony.API(
consumer_secret = self.__class__.consumer_secret,
consumer_key = self.__class__.consumer_key,
access_token = self.__class__.access_token,
access_token_secret = self.__class__.access_token_secret
)
def create_twitter_api():
config_path = expanduser('~/.swittersconfig')
if isfile(config_path):
config = ConfigParser.ConfigParser()
config.read(config_path)
key = config.get('TwitterConfig', 'consumer_key')
secret = config.get('TwitterConfig', 'consumer_secret')
token = config.get('TwitterConfig', 'access_token')
token_secret = config.get('TwitterConfig', 'access_token_secret')
if key[:4] == '<add':
print_help_and_exit()
api = tweetpony.API(consumer_key=key,
consumer_secret=secret,
access_token=token,
access_token_secret=token_secret)
return api
else:
config = ConfigParser.ConfigParser()
config.add_section('TwitterConfig')
config.set('TwitterConfig', 'consumer_key', '<add key here>')
config.set('TwitterConfig', 'consumer_secret', '<add secret here>')
config.set('TwitterConfig', 'access_token', '<add token here>')
config.set('TwitterConfig', 'access_token_secret',
'<add secret token here>')
with open(config_path, 'wb') as configFile:
config.write(configFile)
print_help_and_exit()
def finalize():
global api, twitter_user
api = tweetpony.API(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
access_token=auth_data['access_token'],
access_token_secret=auth_data['access_token_secret'])
twitter_user = api.user
def __init__(self):
self.twitAPI = tweetpony.API(consumer_key = env.TWITTER_CONSUMER_KEY,
consumer_secret = env.TWITTER_CONSUMER_SECRET,
access_token = env.TWITTER_ACCESS_TOKEN_KEY,
access_token_secret = env.TWITTER_ACCESS_TOKEN_SECRET)
user = self.twitAPI.user
print ("Hello " + user.screen_name)
def checkout(request):
spark = SparkCloud(SP_USERNAME,SP_PASSWORD)
"""
" Alternative:
"spark = SparkCloud(SP_ACCESS_TOKEN)
"""
if (spark.<YOUR_CORE_NAME>.connected):
nonce=request.POST.get("payment_method_nonce")
"""
" Finishing the transaction adn getting the result.
"""
result=braintree.Transaction.sale({
"amount":"1.00",
"payment_method_nonce":nonce
})
transaction_id=result.transaction.id
name = request.POST.get("twitterName")
if name != "":
"""
" Calling to Spark Core to show the tweet message at the tft
"""
spark.<YOUR_CORE_NAME>.twitter(name)
api = tweetpony.API(
consumer_key = TP_CONSUMER_KEY,
consumer_secret = TP_CONSUMER_SECRET,
access_token = TP_ACCESS_TOKEN,
access_token_secret = TP_ACCESS_TOKEN_SECRET
)
try:
text = "Hi @"+name+". This is your transaction ID:"+transaction_id+". Please, grab your candies!"
api.update_status(text)
except tweetpony.APIError as err:
print "Oops, something went wrong! Twitter returned error #%i and said: %s" % (err.code, err.description)
else:
print "Yay! Your tweet has been sent!"
"""
" Calling to Spark Core to move the motor
"""
spark.<YOUR_CORE_NAME>.candy(transaction_id)
else:
textMessage = "ERROR: Device not connected"
return render_to_response("checkout.html",locals())
def get_api(): if not os.path.exists(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".auth_data.json")): authenticate() with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".auth_data.json"), 'r') as f: auth_data = json.loads(f.read()) try: api = tweetpony.API(tweetpony.CONSUMER_KEY, tweetpony.CONSUMER_SECRET, auth_data['access_token'], auth_data['access_token_secret']) except tweetpony.APIError as err: print "Oh no! You could not be authenticated. Twitter returned error #%i and said: %s" % (err.code, err.description) else: return api return False
def postTweet_py2(text, image):
import tweetpony
api = tweetpony.API(consumer_key = consumer_key, consumer_secret = consumer_secret, access_token = access_token, access_token_secret = access_token_secret)
user = api.user
try:
if image:
api.update_status_with_single_media(status = text, media=image)
else :
api.update_status(status = text)
except tweetpony.APIError as err:
print("Oops, something went wrong! Twitter returned error #%i and said: %s" % (err.code, err.description))
else:
pass #print "Yay! Your tweet has been sent!"
def authenticate():
try:
api = tweetpony.API(tweetpony.CONSUMER_KEY, tweetpony.CONSUMER_SECRET)
url = api.get_auth_url()
print "Visit this URL to obtain your verification code: %s" % url
verifier = raw_input("Input your code: ")
api.authenticate(verifier)
except tweetpony.APIError as err:
print "Oh no! You could not be authenticated. Twitter returned error #%i and said: %s" % (err.code, err.description)
else:
auth_data = {'access_token': api.access_token, 'access_token_secret': api.access_token_secret}
with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".auth_data.json"), 'w') as f:
f.write(json.dumps(auth_data))
print "Hello, @%s! You have been authenticated. You can now run the other example scripts without having to authenticate every time." % api.user.screen_name
def Initialize_Register(self): """Set up the API user UploadX's registered ID codes""" if self.media=="twitter": consumer_key='ilsxfHf2M9WVFod3I0hOPlqlJ' consumer_secret= 'PD4gKHDVujDaDiMVkK678BVHoAXtYf4bXpEdZoM9dyLAIZ9xVB' self.api = tweetpony.API(consumer_key = consumer_key, consumer_secret = consumer_secret) self.auth_url = self.api.get_auth_url() elif self.media=="dropbox": app_key = 'uehmy7qwfyhnd34' app_secret = 'h1tmocr962j6xfa' self.flow = dropbox.client.DropboxOAuth2FlowNoRedirect(app_key, app_secret)
def post_tweet(news_instance):
tweetpony_config = _get_tweetpony_configuration()
base_url = _get_base_url()
if tweetpony_config:
news_url = '%s%s' % (base_url,
reverse('view_news',
kwargs={'news_slug': news_instance.slug}))
try:
send_mail(
'[labman_NEWS] %s' % news_instance.title,
news_url,
getattr(settings, 'DEFAULT_EMAIL_SENDER', ''),
getattr(settings, 'NEWS_UPDATES_RECEIVERS', []),
)
except:
pass
tweetpony_api = tweetpony.API(
consumer_key=tweetpony_config.consumer_key,
consumer_secret=tweetpony_config.consumer_secret,
access_token=tweetpony_config.access_token,
access_token_secret=tweetpony_config.access_token_secret,
)
# Not needed anymore
# if (tweetpony_config.karmacracy_username and tweetpony_config.karmacracy_api_key):
# tweet_url = _get_short_url(news_url, tweetpony_config)
#
# else:
# tweet_url = news_url
tweet_text = _generate_tweet_text(news_instance)
tweet = '%s: %s' % (tweet_text, news_url)
try:
tweetpony_api.update_status(status=tweet)
except tweetpony.APIError as err:
print "Oops, something went wrong! Twitter returned error #%i and said: %s" % (
err.code, err.description)
def twitter_Upload(file_name, message):
"""Upload an image with a message to your Twitter account"""
settings = ElementTree.parse('settings.xml').getroot()
auth = settings.find('authentication')
twitter_auth = auth.find('twitter')
consumer_key = 'ilsxfHf2M9WVFod3I0hOPlqlJ'
consumer_secret = 'PD4gKHDVujDaDiMVkK678BVHoAXtYf4bXpEdZoM9dyLAIZ9xVB'
access_token = twitter_auth.find('access_token').text
access_token_secret = twitter_auth.find('access_token_secret').text
api = tweetpony.API(consumer_key=consumer_key,
consumer_secret=consumer_secret,
access_token=access_token,
access_token_secret=access_token_secret)
user = api.user
text = message
# text = "test"
picture = open(file_name, "r")
api.update_status_with_media(status=text, media=[picture])
return ""
def main():
api = tweetpony.API(consumer_key=config['consumer_key'],
consumer_secret=config['consumer_secret'],
access_token=config['access_token'],
access_token_secret=config['access_token_secret'])
user = api.user
sensor_handler = sensor.sensor()
temperature = sensor_handler.get_last_value(0)
humidity = sensor_handler.get_last_value(1)
pressure = sensor_handler.get_last_value(2)
try:
api.update_status(status=u'Witaj Dobra, mamy właśnie ' +
unicode(str(temperature)) + u'C i ' +
unicode(str(humidity)) + u'% wilgotności')
except tweetpony.APIError as err:
print "Oops, something went wrong! Twitter returned error #%i and said: %s" % (
err.code, err.description)
else:
print "Yay! Your tweet has been sent!"
'x-sonos-http:_t%3a%3a1163595.mp3?sid=11&flags=32'
],
'049e6422c52980': [
'11', 'Yo-Yo Ma & Bobby McFerrin: Flight of the Bumblebee', 1.2,
time_offset, 'x-sonos-http:_t%3a%3a8805968.mp3?sid=11&flags=32'
],
'04536422c52980': [
'12', 'Desmond De Silva: Babi Achchee', 0.8, time_offset,
'x-sonos-http:_t%3a%3a43013728.mp3?sid=11&flags=32'
],
}
# Twitter setup
print("Connecting to Twitter...")
api = tweetpony.API(consumer_key=My_Consumer_Key,
consumer_secret=My_Consumer_Secret,
access_token=My_Access_Token,
access_token_secret=My_Token_Secret)
user = api.user
print "Connected to Twitter as @%s!" % user.screen_name
lcd.clear()
lcd.message('Connected to\nTwitter')
##else:
## print ("Twitter connection error")
##print ("")
# Sonos setup
print("Connecting to Sonos...")
sonos = SoCo(sonos_ip)
print("Connected to Sonos: " + sonos.player_name)
lcd.clear()
lcd.message('Connected to\nSonos & Twitter')
def parse_twitter(temp):
twitter = tweetpony.API(conf['tw_api_key'], conf['tw_api_secret'],
conf['tw_acc_token'], conf['tw_tok_secret'])
followers = json.loads(twitter.followers().json)['users']
name = str(followers[0]['screen_name'].ljust(15))
return temp.replace('{{tw_follower}}', name)
friends = twitter.get_friends_list(screen_name=u, count=n)
followers = twitter.get_followers_list(screen_name=u, count=n)
end = time.time()
twittersec.append(end - start)
friendslen.append(len(friends))
followerslen.append(len(followers))
# Calculating time for TweetPony
start = time.time()
api = tweetpony.API(
consumer_key="s08vLRIM5VnqCUqFVYTaV3ET9",
consumer_secret="q4N5vB5KQrakhjAcWAk8dKOeTn4896cURoAg33A37UjGG2jJxf",
access_token="897909419996041218-FIxS4NDoYbgrorjbxns9hYadZDiLg3J",
access_token_secret="4p4RMc15bPp5Mknywkc1dY5HbbsJDwSnOGkcw4KLSFyQz")
followers = api.followers(screen_name=u, count=n)
friends = api.friends(screen_name=u, count=n)
end = time.time()
twittersec.append(end - start)
friendslen.append(len(friends))
followerslen.append(len(followers))
# Calculating time for TwitterAPI
start = time.time()
def main():
parser = argparse.ArgumentParser(
description="Tweet polling for AM03127 LED sign")
parser.add_argument('-d',
'--device',
default="/dev/ttyUSB0",
help="Serial device to use")
parser.add_argument('-b',
'--baudrate',
type=int,
choices=(1200, 2400, 4800, 9600, 19200),
default=9600,
help="Baudrate for the serial port")
parser.add_argument('-i',
'--id',
type=int,
default=1,
help="ID of the LED sign")
parser.add_argument('-s',
'--speed',
choices=('slowest', 'slow', 'medium', 'fast'),
default='fast',
help="Effect speed")
parser.add_argument('-m',
'--method',
choices=('normal', 'blinking', 'song_1', 'song_2',
'song_3'),
default='normal',
help="Display effect while waiting")
parser.add_argument('-w',
'--wait',
type=float,
default=2.0,
help="Time to show the text until it disappears")
parser.add_argument('-lead',
'--lead',
choices=('immediate', 'xopen', 'curtain_up',
'curtain_down', 'scroll_left', 'scroll_right',
'vopen', 'vclose', 'scroll_up', 'scroll_down',
'hold', 'snow', 'twinkle', 'block_move',
'random', 'hello_world', 'welcome', 'amplus'),
default='scroll_left',
help="Leading effect")
parser.add_argument('-lag',
'--lag',
choices=('immediate', 'xopen', 'curtain_up',
'curtain_down', 'scroll_left', 'scroll_right',
'vopen', 'vclose', 'scroll_up', 'scroll_down',
'hold'),
default='scroll_down',
help="Lagging effect")
parser.add_argument(
'-tf',
'--token-file',
type=str,
default="twitter_tokens.json",
help=
"A JSON file containing the Twitter API tokens (see source code for key names)"
)
parser.add_argument(
'-bf',
'--blacklist-file',
type=str,
default="twitter_blacklist.json",
help=
"A JSON file containing the blacklisted stuff (see source code for key names)"
)
parser.add_argument(
'-k',
'--keywords',
type=str,
required=True,
help="A comma-separated list of tweet keywords to poll")
parser.add_argument(
'-pi',
'--polling-interval',
type=int,
default=5,
help="The pause between requests to Twitter, in minutes")
parser.add_argument('-c',
'--count',
type=int,
default=26,
help="How many tweets to send to the sign")
args = parser.parse_args()
with open(args.token_file, 'r') as f:
keys = json.load(f)
with open(args.blacklist_file, 'r') as f:
blacklist = json.load(f)
sign = ledsign.am03127.LEDSign(port=args.device,
baudrate=args.baudrate,
timeout=None,
id=args.id)
settings = {
'speed': getattr(sign, "SPEED_%s" % args.speed.upper()),
'method': getattr(sign, "METHOD_%s" % args.method.upper()),
'wait': args.wait,
'lead': getattr(sign, "EFFECT_%s" % args.lead.upper()),
'lag': getattr(sign, "EFFECT_%s" % args.lag.upper())
}
message_parser = ledsign.am03127.parsers.PageContentBBCodeParser()
api = tweetpony.API(keys['consumer_key'], keys['consumer_secret'],
keys['access_token'], keys['access_token_secret'])
try:
while True:
raw_results = []
for keyword in args.keywords.split(","):
raw_results += [
tweet for tweet in api.search_tweets(
q=keyword, result_type='recent', count=30)
]
raw_results.sort(key=lambda tweet: tweet.created_at, reverse=True)
results = []
for index, status in enumerate(raw_results):
# Ignore replies and retweets and apply the blacklists
if not (status.text.startswith("@") or hasattr(
status, 'retweeted_status') or "RT @" in status.text):
filtered = False
for word in blacklist['words']:
if word.lower() in status.clean_text().lower():
filtered = True
break
for client in blacklist['clients']:
if status.source.lower() == client.lower():
filtered = True
break
for user in blacklist['users']:
if status.user.screen_name.lower() == user.lower():
filtered = True
break
if not filtered:
results.append(status)
results = results[:args.count]
# Set the pages to run
sign.send_schedule(
schedule="A",
pages="ABCDEFGHIJKLMNOPQRSTUVWXYZ"[:len(results)])
for index, status in enumerate(results):
text = re.sub(
r"(#.+?)(?=\s|$)", "[color=green]\\1[color=orange]",
status.clean_text().replace("\n",
" ")) # Color hashtags green
text = re.sub(r"(@\S+?)(?=\s|$)",
"[color=red]\\1[color=orange]",
text) # Color user mentions red
text = re.sub(r"https{0,1}://[a-zA-Z0-9./]+",
"[font=narrow][link][font=normal]",
text) # Replace URLs with a placeholder
content = message_parser.render(
"[color=red]@%s: [color=orange]%s" %
(status.user.screen_name, text)).render()
content = "".join(
[chr(ord(char)) for char in content]
) # Turn the text into 8-bit ASCII instead of UTF-8 encoded 7-bit ASCII
success = sign.send_page(
page="ABCDEFGHIJKLMNOPQRSTUVWXYZ"[index],
lead=settings['lead'],
speed=settings['speed'],
method=settings['method'],
wait=settings['wait'],
lag=settings['lag'],
content=content)
if not success:
success = sign.send_page(
page="ABCDEFGHIJKLMNOPQRSTUVWXYZ"[index],
lead=settings['lead'],
speed=settings['speed'],
method=settings['method'],
wait=settings['wait'],
lag=settings['lag'],
content=content)
success_str = " OK " if success else "FAIL"
print "[%s] %s %s" % (success_str,
status.user.screen_name.ljust(15),
status.clean_text().replace("\n", " "))
print "Next poll at %s\n" % (
datetime.datetime.now() + datetime.timedelta(
seconds=args.polling_interval * 60)).strftime("%H:%M:%S")
time.sleep(args.polling_interval * 60)
except KeyboardInterrupt:
pass
#!/usr/bin/python
import subprocess
import datetime
import time
import os
import RPi.GPIO as io
import tweepy
import tweetpony
api = tweetpony.API(consumer_key="abcd",
consumer_secret="efgh",
access_token="ijkl",
access_token_secret="mnop")
io.setmode(io.BCM)
pir_pin = 18
flashingLight_pin = 7
io.setup(pir_pin, io.IN)
io.setup(flashingLight_pin, io.OUT)
io.output(flashingLight_pin, io.LOW)
# --------- Main Program ---------
previous_pir = 0
while True:
current_pir = io.input(pir_pin)
if previous_pir == 0 and current_pir == 1:
with open("/home/pi/Alarm/armed.txt", "r") as fo:
def main():
parser = argparse.ArgumentParser(description = "Tweet streamer for AM03127 LED sign")
parser.add_argument('-d', '--device',
default = "/dev/ttyUSB0",
help = "Serial device to use")
parser.add_argument('-b', '--baudrate',
type = int,
choices = (1200, 2400, 4800, 9600, 19200),
default = 9600,
help = "Baudrate for the serial port")
parser.add_argument('-i', '--id',
type = int,
default = 1,
help = "ID of the LED sign")
parser.add_argument('-p', '--page',
choices = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'),
default = 'A',
help = "The page to send the tweets to")
parser.add_argument('-s', '--speed',
choices = ('slowest', 'slow', 'medium', 'fast'),
default = 'fast',
help = "Effect speed")
parser.add_argument('-m', '--method',
choices = ('normal', 'blinking', 'song_1', 'song_2', 'song_3'),
default = 'normal',
help = "Display effect while waiting")
parser.add_argument('-w', '--wait',
type = float,
default = 2.0,
help = "Time to show the text until it disappears")
parser.add_argument('-lead', '--lead',
choices = ('immediate', 'xopen', 'curtain_up', 'curtain_down', 'scroll_left', 'scroll_right', 'vopen', 'vclose', 'scroll_up', 'scroll_down', 'hold', 'snow', 'twinkle', 'block_move', 'random', 'hello_world', 'welcome', 'amplus'),
default = 'scroll_left',
help = "Leading effect")
parser.add_argument('-lag', '--lag',
choices = ('immediate', 'xopen', 'curtain_up', 'curtain_down', 'scroll_left', 'scroll_right', 'vopen', 'vclose', 'scroll_up', 'scroll_down', 'hold'),
default = 'scroll_down',
help = "Lagging effect")
parser.add_argument('-tf', '--token-file',
type = str,
default = "twitter_tokens.json",
help = "A JSON file containing the Twitter API tokens (see source code for key names)")
parser.add_argument('-bf', '--blacklist-file',
type = str,
default = "twitter_blacklist.json",
help = "A JSON file containing the blacklisted stuff (see source code for key names)")
parser.add_argument('-k', '--keywords',
type = str,
required = True,
help = "A comma-separated list of tweet keywords to stream")
args = parser.parse_args()
with open(args.token_file, 'r') as f:
keys = json.load(f)
with open(args.blacklist_file, 'r') as f:
blacklist = json.load(f)
sign = ledsign.am03127.LEDSign(
port = args.device,
baudrate = args.baudrate,
timeout = None,
id = args.id
)
# Set the page to run
sign.send_schedule(
schedule = "A",
pages = args.page
)
settings = {
'speed': getattr(sign, "SPEED_%s" % args.speed.upper()),
'method': getattr(sign, "METHOD_%s" % args.method.upper()),
'wait': args.wait,
'lead': getattr(sign, "EFFECT_%s" % args.lead.upper()),
'lag': getattr(sign, "EFFECT_%s" % args.lag.upper())
}
message_parser = ledsign.am03127.parsers.PageContentBBCodeParser()
class LEDSignStreamProcessor(tweetpony.StreamProcessor):
def on_status(self, status):
# Ignore replies and retweets and apply the blacklists
if status.text.startswith("@") or hasattr(status, 'retweeted_status') or "RT @" in status.text:
return True
for word in blacklist['words']:
if word.lower() in status.clean_text().lower():
return True
for client in blacklist['clients']:
if status.source.lower() == client.lower():
return True
for user in blacklist['users']:
if status.user.screen_name.lower() == user.lower():
return True
text = re.sub(r"(#.+?)(?=\s|$)", "[color=green]\\1[color=orange]", status.clean_text().replace("\n", " ")) # Color hashtags green
text = re.sub(r"(@\S+?)(?=\s|$)", "[color=red]\\1[color=orange]", text) # Color user mentions red
text = re.sub(r"https{0,1}://[a-zA-Z0-9./]+", "[link]", text) # Replace URLs with a placeholder
content = message_parser.render("[color=red]@%s: [color=orange]%s" % (status.user.screen_name, text)).render()
content = "".join([chr(ord(char)) for char in content]) # Turn the text into 8-bit ASCII instead of UTF-8 encoded 7-bit ASCII
success = sign.send_page(
page = args.page,
lead = settings['lead'],
speed = settings['speed'],
method = settings['method'],
wait = settings['wait'],
lag = settings['lag'],
content = content
)
if not success:
success = sign.send_page(
page = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[index],
lead = settings['lead'],
speed = settings['speed'],
method = settings['method'],
wait = settings['wait'],
lag = settings['lag'],
content = content
)
success_str = " OK " if success else "FAIL"
print "[%s] %s %s" % (success_str, status.user.screen_name.ljust(15), status.clean_text().replace("\n", " "))
return True
api = tweetpony.API(keys['consumer_key'], keys['consumer_secret'], keys['access_token'], keys['access_token_secret'])
processor = LEDSignStreamProcessor(api)
try:
api.filter_stream(track = args.keywords, processor = processor)
except KeyboardInterrupt:
pass
def __init__(self, consumer_key, consumer_secret, access_token,
access_token_secret):
self.api = tweetpony.API(consumer_key, consumer_secret, access_token,
access_token_secret)
io.setup(green_led, io.OUT)
io.setup(red_led, io.OUT)
io.setup(set_button, io.IN, pull_up_down=io.PUD_UP)
io.output(green_led, False)
io.output(red_led, False)
# Photo dimensions and rotation
photo_width = 640
photo_height = 480
photo_rotate = 0
# to allow for more than one photo a minute
# photo_count = 0
#connect to twitter using tweetpony
api = tweetpony.API(consumer_key = "xxx", consumer_secret = "xxx", access_token = "xxx", access_token_secret = "")
mode = "wait"
print("waiting...")
while True:
while mode == "wait":
io.output(red_led, False)
io.output(green_led, True)
time.sleep(.1)
io.output(green_led, False)
time.sleep(.1)
if not io.input(set_button):
mode = "go"
print("ready to go....")
time.sleep(5)
def login():
auth_data = None
def finalize():
global api, twitter_user
api = tweetpony.API(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
access_token=auth_data['access_token'],
access_token_secret=auth_data['access_token_secret'])
twitter_user = api.user
try:
with open(oauth_filename, "r") as f:
auth_data = json.loads(f.read())
except IOError:
pass
else:
try:
finalize()
except tweetpony.APIError as err:
print("Twitter login error:", err, err.code, err.description)
print("trying to relogin...")
else:
return
# api = tweetpony.API(consumer_key = tweetpony.CONSUMER_KEY, consumer_secret = tweetpony.CONSUMER_SECRET)
api = tweetpony.API(consumer_key=consumer_key,
consumer_secret=consumer_secret)
# Start a small webserver to provide a simple callback URL to
# get the oauth token.
class OAuthReturnHandler:
# noinspection PyMethodParameters
def __init__(o_self):
o_self.httpd = None # type: typing.Optional[http.server.HTTPServer]
o_self.httpd_access_token_callback = None
class Handler(http.server.BaseHTTPRequestHandler):
# noinspection PyShadowingBuiltins
def log_message(self, format, *args):
pass
# noinspection PyPep8Naming,PyMethodParameters
def do_GET(web_self):
path_start = "/get_access_token?"
if web_self.path.startswith(path_start):
o_self.httpd_access_token_callback = web_self.path[
len(path_start):]
web_self.send_response(200)
web_self.send_header("Content-type", "text/html")
web_self.end_headers()
web_self.wfile.write(b"""
<html><head><title>OAuth return</title></head>
<body onload="onLoad()">
<script type="text/javascript">
function onLoad() {
ww = window.open(window.location, "_self");
ww.close();
}
</script>
</body></html>""")
else:
web_self.send_response(404)
web_self.end_headers()
o_self.handler = Handler
def try_or_fail(fn):
# noinspection PyBroadException
try:
fn()
return True
except Exception:
return False
# Try with some default ports first to avoid cluttering the users Google Authorized Access list.
(try_or_fail(lambda: o_self.start_server(port=8123))
or try_or_fail(lambda: o_self.start_server(port=8321))
or o_self.start_server(port=0))
_, o_self.port = o_self.httpd.server_address
o_self.oauth_callback_url = "http://localhost:%d/get_access_token" % o_self.port
def start_server(self, port):
self.httpd = http.server.HTTPServer(("", port), self.handler)
def wait_callback_response(self):
while self.httpd_access_token_callback is None:
self.httpd.handle_request()
return self.httpd_access_token_callback
oauth_return_handler = OAuthReturnHandler()
# monkey-patch. we need to use POST for callback_url (https://dev.twitter.com/docs/api/1/get/oauth/authorize)
# upstream bug report: https://github.com/Mezgrman/TweetPony/issues/5
def get_request_token(self, callback_url=None):
url = self.build_request_url(self.oauth_root, 'request_token')
resp = self.do_request("POST", url, callback_url, is_json=False)
token_data = self.parse_qs(resp)
self.set_request_token(token_data['oauth_token'],
token_data['oauth_token_secret'])
return self.request_token, self.request_token_secret, token_data.get(
'oauth_callback_confirmed')
tweetpony.API.get_request_token = get_request_token
# monkey-patch to get detailed error information
# workaround for this issue: https://github.com/Mezgrman/TweetPony/issues/6
orig_post = requests.post
def post_wrapper(*args, **kwargs):
resp = orig_post(*args, **kwargs)
if resp.status_code != 200:
print("POST error code", resp.status_code)
print(resp)
print(resp.text)
return resp
requests.post = post_wrapper
auth_url = api.get_auth_url(
callback_url=oauth_return_handler.oauth_callback_url)
print("open oauth login page")
webbrowser.open(auth_url)
print("waiting for redirect callback ...", end=' ')
httpd_access_token_callback = oauth_return_handler.wait_callback_response()
print("done login")
from urllib.parse import parse_qs
token = parse_qs(httpd_access_token_callback)
api.authenticate(token["oauth_verifier"])
auth_data = {
'access_token': api.access_token,
'access_token_secret': api.access_token_secret
}
with open(oauth_filename, 'w') as f:
f.write(json.dumps(auth_data))
finalize()
import tweetpony
import threading
from threading import Timer
# This is the TweetPony object to use with your Twitter credentials
api = tweetpony.API(consumer_key = "<your key>", consumer_secret = "<your secret>", access_token = "<your oauth token>", access_token_secret = "<your oauth token secret")
user = api.user
print "Hello, @%s!" % user.screen_name
### Set the user ids for whom you want to find followers
userIds = [1234, 2345, etc.]
# The file name. Function will keep appending to this file with each run of script. If re-run with same userids above could wind up with repeated values. Can rename as often as like.
fileName = 'FollowersIds'
# This function gets called recursively to get all the followers of the ids above and put them in a csv in C:\Temp
# Handles multiple cursors of followers for an individual user
# Throttles requests to Twitter API to pause after 15 requests, wait until Twitter's limit window has passed (15 minutes), then continue
def getFollowersIds(userIdIndex, nextCursor, requestNum, f):
currentUserId = userIds[userIdIndex]
followersIds = None
userAuthorized = True
try:
if nextCursor > 0:
followersIds = api.followers_ids(user_id = currentUserId, cursor = nextCursor)
else:
followersIds = api.followers_ids(user_id = currentUserId)
if f.closed:
f = open(f.name, f.mode)
for followerId in followersIds.ids:
f.write('\n' + str(currentUserId) + ',' + str(followerId))
except tweetpony.APIError as err:
errMess = "Error in call to Twitter: "
