def run(self):
pp = pprint.PrettyPrinter(depth=6)
api = Twython(app_key=options.consumer_key,
app_secret=options.consumer_secret,
oauth_token=options.access_token_key,
oauth_token_secret=options.access_token_secret)
#do_simulate = True
do_simulate = False
current_user = { 'id_str' : '1041065317' }
if not do_simulate:
current_user = api.verifyCredentials()
pp.pprint(current_user)
fortuneComposer = FortuneComposer()
followController = follow.FollowController([ follow.FollowComposer(current_user) ], current_user=current_user)
retweetController = retweet.RetweetController([ retweet.RetweetComposer() ], current_user=current_user)
replyController = reply.ReplyController([ fortuneComposer ], current_user=current_user)
postController = post.PostController([ fortuneComposer ], current_user=current_user)
default_time_to_sleep = 1
if do_simulate:
default_time_to_sleep = 1
user_stream = stream.Stream(api,
{ 'endpoint' : 'https://userstream.twitter.com/1.1/user.json', 'track' : 'bucketobytes' },
[ followController, retweetController, replyController, postController ],
default_time_to_sleep,
do_simulate)
user_stream.connectStream()
def logged_in(request):
user = request.user.twitterprofile
twitter = Twython(
twitter_token= settings.TWITTER_KEY,
twitter_secret = settings.TWITTER_SECRET,
oauth_token = user.oauth_token,
oauth_token_secret = user.oauth_secret
)
user_data = twitter.verifyCredentials()
return render_to_response('logged_in.html', {'user_data': user_data})
def authenticate(self, oauth_token=None, oauth_secret=None):
'''
Authenticates the oauth credentials by requesting user information
from twitter.
'''
api = Twython(
twitter_token = CONSUMER_KEY,
twitter_secret = CONSUMER_SECRET,
oauth_token = oauth_token,
oauth_token_secret = oauth_secret
)
twitter_user = api.verifyCredentials()
username = '******'.join([str(twitter_user['id']), 'twitter'])
try:
user = User.objects.get(username=username)
except:
# User wasn't been registered through this backend
return None
return user
def twitter_return(request, window_type):
"""
A user gets redirected here after hitting Twitter and authorizing your
app to use their data.
This is the view that stores the tokens you want
for querying data. Pay attention to this.
"""
# Now that we've got the magic tokens back from Twitter, we need to exchange
# for permanent ones and store them...
api = Twython(
twitter_token = CONSUMER_KEY,
twitter_secret = CONSUMER_SECRET,
oauth_token = request.session['request_token']['oauth_token'],
oauth_token_secret = request.session['request_token']['oauth_token_secret']
)
# Retrieve the tokens we want...
twitter_tokens = api.get_authorized_tokens()
api = get_authorized_twython(twitter_tokens)
username = '******'.join([str(twitter_tokens['user_id']), 'twitter'])
request.session['twitter_tokens'] = twitter_tokens
# No need to call authorize because of get_authorized_tokens()
# Probable bug - need to fix when TwitterUserProfile already exists without
# user having logged in.
try:
user = User.objects.get(username=username)
up = UserProfile.objects.get(user=user)
twitter_user = TwitterUserProfile.objects.get(user=up)
except:
# Create User, UserProfile, TwitterUserProfile
twitter_user = api.verifyCredentials()
if 'error' in twitter_user:
del request.session['access_token']
del request.session['request_token']
return HttpResponse("Unable to authenticate you!")
name = twitter_user['name'].split()
if(len(name) > 0):
first_name = name[0]
else:
first_name = "Unknown User"
if(len(name) > 1):
last_name = name[1]
else:
last_name = ""
user = User(username=username, first_name=first_name, last_name=last_name)
user.set_unusable_password()
user.save()
up = UserProfile(user=user)
# whale = Whale(species=WhaleSpecies.getDefaultSpecies())
# whale.save()
# up.whale = whale
up.save()
try:
tp = TwitterUserProfile.objects.get(user_id=user.id)
except TwitterUserProfile.DoesNotExist:
tp = TwitterUserProfile()
tp.__dict__.update(twitter_user)
tp.user = up
tp.oauth_token = twitter_tokens['oauth_token']
tp.oauth_secret = twitter_tokens['oauth_token_secret']
tp.active_classifier = DEFAULT_CLASSIFIER
tp.classifier_version = DEFAULT_CLASSIFIER_VERSION
tp.save()
# Hack so don't have to call authenticate
user.backend = 'twitter.auth.TwitterAuthentication'
login(request, user)
if window_type == 'popup':
return render_to_response("twitter/twitter_return.html", {'twitter_user': twitter_user},
context_instance=RequestContext(request))
elif window_type == 'api':
return HttpResponse()
else:
return HttpResponseRedirect("/")
print "No consumer key"
exit()
pp = pprint.PrettyPrinter(depth=6)
api = Twython(app_key=options.consumer_key,
app_secret=options.consumer_secret,
oauth_token=options.access_token_key,
oauth_token_secret=options.access_token_secret)
rates = api.getRateLimitStatus()
remaining_hits = rates['remaining_hits']
rate_reset = rates['reset_time_in_seconds']
print 'Rate limit: ' + str(remaining_hits)
current_user = api.verifyCredentials()
fortunes = open('fortunes').read().split('\n%\n')
if len(fortunes) == 0:
exit()
for fortune in fortunes:
if len(fortune) > 140:
fortunes.remove(fortune)
def followed(follow):
source_id = follow['source']['id_str']
target_id = follow['target']['id_str']
new_id = ""
if source_id != current_user['id_str']:
new_id = source_id
class TwitterServer:
def __init__(self):
# You can choose to latch tweets topics
latch = False
if rospy.has_param('latch'):
latch = rospy.get_param('latch')
# In case you can't direct message a user, replace DM with a public
# '@user text' tweet.
self.replace_dm = False
if rospy.has_param('replace_dm'):
self.replace_dm = rospy.get_param('replace_dm')
# Publish mentions, home timeline and direct messages
self.pub_home = rospy.Publisher('home_timeline', Tweets, latch = latch)
self.pub_mentions = rospy.Publisher('mentions', Tweets, latch = latch)
self.pub_dm = rospy.Publisher('direct_messages', Tweets, latch = latch)
# Create a bridge for images conversions
self.bridge = CvBridge()
# Last Tweets (init values are twitter API default)
self.last_mention = 12345
self.last_timeline = 12345
self.last_dm = 12345
oauth_token = None
oauth_token_secret = None
# Get OAuth info through parameter server
if rospy.has_param('~token'):
oauth_token = rospy.get_param('~token')
if rospy.has_param('~token_secret'):
oauth_token_secret = rospy.get_param('~token_secret')
# OAuth token creation (see get_access_token.py from python-twitter)
if oauth_token is None or oauth_token_secret is None:
rospy.loginfo("No OAuth information given, trying to create...")
t = Twython( app_key = 'HbAfkrfiw0s7Es4TVrpSuw',
app_secret = 'oIjEOsEbHprUa7EOi3Mo8rNBdQlHjTGPEpGrItZj8c')
# Get AUth URL. Use for login for security,
url = t.get_authentication_tokens()
t = Twython(app_key = 'HbAfkrfiw0s7Es4TVrpSuw',
app_secret = 'oIjEOsEbHprUa7EOi3Mo8rNBdQlHjTGPEpGrItZj8c',
oauth_token = url['oauth_token'],
oauth_token_secret = url['oauth_token_secret'])
# Open web browser on given url
import webbrowser
webbrowser.open( url['auth_url'] )
rospy.logwarn("Log your twitter, allow TwitROS and copy pincode.")
# Wait to avoid webbrowser to corrupt raw_input
rospy.sleep( rospy.Duration( 5 ) )
# Enter pincode
pincode = raw_input('Pincode: ').strip()
auth_props = t.get_authorized_tokens(oauth_verifier = pincode)
oauth_token = auth_props['oauth_token']
oauth_token_secret = auth_props['oauth_token_secret']
rospy.loginfo("Using the following parameters for oauth: "
+ 'key: [{key}], '.format(key = oauth_token)
+ 'secret: [{secret}]'.format(secret = oauth_token_secret))
# Consumer key and secret are specific to this App.
# Access token are given through OAuth for those consumer params
rospy.loginfo('Trying to log into Twitter API...')
# Twython
self.t = Twython(app_key = 'HbAfkrfiw0s7Es4TVrpSuw',
app_secret = 'oIjEOsEbHprUa7EOi3Mo8rNBdQlHjTGPEpGrItZj8c',
oauth_token = oauth_token,
oauth_token_secret = oauth_token_secret)
result = self.t.verifyCredentials();
rospy.loginfo("Twitter connected as {name} (@{user})!"
.format(name = result['name'], user = result['screen_name']))
# Stock screen name (used to show friendships)
self.name = result['screen_name']
# Advertise services
self.post = rospy.Service('post_tweet', Post, self.post_cb)
self.retweet = rospy.Service('retweet', Id, self.retweet_cb)
self.follow = rospy.Service('follow', User, self.follow_cb)
self.unfollow = rospy.Service('unfollow', User, self.unfollow_cb)
self.post_dm = rospy.Service('post_dm', DirectMessage, self.post_dm_cb)
self.destroy = rospy.Service('destroy_dm', Id, self.destroy_cb)
self.timeline = rospy.Service(
'user_timeline', Timeline, self.user_timeline_cb)
# Create timers for tweet retrieval. Use oneshot and retrigger
timer_home = rospy.Timer(
rospy.Duration(1), self.timer_home_cb, oneshot = True )
timer_mentions = rospy.Timer(
rospy.Duration(2), self.timer_mentions_cb, oneshot = True )
timer_dm = rospy.Timer(
rospy.Duration(3), self.timer_dm_cb, oneshot = True )
# Tweet callback
def post_cb(self, req):
txt = req.text
rospy.logdebug("Received a tweet: " + txt)
# If only one picture, use twitter upload
if len(req.images) == 1:
path = self.save_image( req.images[0] )
first = True
for tweet in self.split_tweet( txt ):
if (req.reply_id == 0):
if first:
result = self.t.updateStatusWithMedia(
file_ = path, status = tweet )
first = False
else:
result = self.t.updateStatus( status = tweet )
else:
if first:
result = self.t.updateStatusWithMedia( file_ = path,
status = tweet, in_reply_status_id = req.reply_id )
first = False
else:
result = self.t.updateStatus( status = tweet,
in_reply_to_status_id = req.reply_id )
# Check response for each update.
if self.t.get_lastfunction_header('status') != '200 OK':
return None
os.system('rm -f ' + path)
elif len(req.images) != 0:
txt += upload( req.images )
# Publish after splitting.
for tweet in self.split_tweet( txt ):
if (req.reply_id == 0):
result = self.t.updateStatus( status = tweet )
else:
result = self.t.updateStatus(
status = tweet, in_reply_to_status_id = req.reply_id )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
return PostResponse(id = result['id'])
def retweet_cb(self, req):
result = self.t.retweet( id = req.id )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
else:
return IdResponse()
# Does not raise an error if you are already following the user
def follow_cb(self, req):
rospy.logdebug("Asked to follow:" + req.user)
result = self.t.createFriendship( screen_name = req.user )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
else:
return UserResponse()
# Does not raise an error if you are not following the user
def unfollow_cb(self, req):
rospy.logdebug("Asked to unfollow:" + req.user)
result = self.t.destroyFriendship( screen_name = req.user )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
else:
return UserResponse()
# Send direct message.
def post_dm_cb(self, req):
rospy.logdebug("Received DM to " + req.user + ": " + req.text)
# First, check if you can dm the user
relation = self.t.showFriendship(
source_screen_name = self.name, target_screen_name = req.user )
if self.t.get_lastfunction_header('status') != '200 OK':
rospy.logerr("Failed to get friendship information.")
return None
# CASE 1: If can, send a direct message
if relation['relationship']['source']['can_dm']:
txt = req.text
# Upload image to postimage.org using requests
if len(req.images):
txt += self.upload( req.images )
for dm in self.split_tweet( txt ):
result = self.t.sendDirectMessage(
screen_name = req.user, text = dm )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
# Return the id of the last DM posted.
return DirectMessageResponse(id = result['id'])
# CASE 2: If Cant dm but allowed to tweet instead, tweet with mention
elif self.replace_dm:
rospy.logwarn("You can't send a direct message to "
+ req.user + ". Sending a public tweet instead...")
# One image ---> Twitter
if len(req.images) == 1 :
path = self.save_image( req.images[0] )
first = True
for tweet in self.split_tweet( req.text ):
if first:
result = self.t.updateStatusWithMedia( file_ = path,
status = tweet )
first = False
else:
result = self.t.updateStatus( status = tweet )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
os.system('rm -rf ' + path)
# Return the id of the last DM posted.
return DirectMessageResponse(id = result['id'])
else:
status = '@' + req.user + ' ' + req.text
# Many images ---> postimage.org
if len(req.images) != 0:
status += upload( req.images )
for tweet in self.split_tweet( status ):
result = self.t.updateStatus( status = tweet )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
# Return the id of the last DM posted.
return DirectMessageResponse(id = result['id'])
# CASE 3: If can't.
else:
rospy.logwarn("You can't send a direct message to " + req.user)
return None
def destroy_cb(self, req):
result = self.t.destroyDirectMessage( id = req.id )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
else:
return IdResponse()
def user_timeline_cb(self, req):
result = self.t.getUserTimeline( screen_name = req.user )
if self.t.get_lastfunction_header('status') != '200 OK':
return None
else:
msg = self.process_tweets( result )
if msg:
return TimelineResponse( tweets = msg )
else:
rospy.logwarn(req.user + " has no tweets in its timeline.")
return TimelineResponse( )
# Split a long text into 140 chars tweets
def split_tweet(self, text):
tweet = ""
tweets = []
words = text.split(' ')
for word in words:
if len(tweet + word + " ") > 137:
tweets.append(tweet.strip() + "...")
# If tweets is intended to a user, begin all tweets with @user
if text.startswith('@'):
tweet = words[0] + " " + word + " "
else:
tweet = "..."
else:
tweet = tweet + word + " "
tweets.append( tweet.strip() )
return tweets
# Upload array of sensor_msgs/Image to postimage.org and return link.
# Link is shortened if possible.
def upload(self, images):
files = {}
paths = [] # Keep paths stored to remove files later
# Construct files dict
i = 0
for image in images:
paths.append( self.save_image( image ) )
files['upload[{count}]'.format(count = i)] = open(paths[i], 'rb')
i += 1
# Post using requests
request = requests.post('http://postimage.org/index.php',
files = files, params = {'optsize': 0, 'adult': 'no'})
# Cleanup saved files
for path in paths:
os.system('rm -rf ' + path)
if not request.status_code in [301, 201, 200]:
return " [FAILED UPLOAD]"
# Parse HTML page returned using beautifulsoup
soup = BeautifulSoup(request.text, 'html.parser')
# Find the image link: Hacked that by looking at raw html file
url = ""
if len(images) == 1:
# 1 image : find first solo link containg 'postimg'
for link in soup.find_all('a'):
if link.get('href').find('postimg') != -1:
url = link.get('href')
break
else:
# Many images: find the option field for gallery url
for option in soup.find_all('option'):
if option.get('value').find('gallery') != -1:
url = option.get('value')
break
if not len(url):
return " [FAILED PARSING OR UPLOAD]"
# Shorten URL
request = requests.get( 'http://is.gd/create.php',
params = {'format': 'simple', 'url': url} )
if request.status_code in [301, 201, 200]:
return " [" + request.text + "]"
else:
return " [" + url + "]"
# Save a sensor_msgs/Image on /tmp and return the path
def save_image(self, image):
# Convert from ROS message using cv_bridge.
try:
cv_image = self.bridge.imgmsg_to_cv(
image, desired_encoding = 'passthrough')
except CvBridgeError, e:
rospy.logerr(e)
# Write to JPG with OpenCV
path = "/tmp/pic_ul_{time}.png".format( time = time() )
cv.SaveImage( path, cv_image )
return path
