class TwitterAdapter(MessageProvider, ImageProvider):
id = 'twitter'
name = 'TwitterAdapter'
def __init__(self, user, *args, **kwargs):
self.user = user
self.social_token = SocialToken.objects.filter(app__provider='twitter',
account__provider='twitter',
account__user=user)
self.social_app = SocialApp.objects.filter(id=self.social_token.get().app.id)
self.twitter = Twython(self.social_app.get().client_id, self.social_app.get().secret,
self.social_token.get().token,
self.social_token.get().token_secret)
self.twitter.verify_credentials()
def publish_image(self, image, message='', **kwargs):
img = open(image.path).read()
try:
logger.info('try to update twitter status with an image, for user: %s ' % self.user)
result = self.twitter.update_status_with_media(status=message, media=StringIO(img))
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def publish_message(self, message, **kwargs):
try:
logger.info('try to update twitter status, for user: %s ' % self.user)
result = self.twitter.update_status(status=message)
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def get_tokens(screen_name):
app_key = dal.get_token("twitter app key " + screen_name)
app_secret = dal.get_token("twitter app secret " + screen_name)
final_key = dal.get_token("twitter final key " + screen_name)
final_secret = dal.get_token("twitter final secret " + screen_name)
if not final_key or not final_secret:
twitter = Twython(app_key, app_secret)
auth = twitter.get_authentication_tokens()
oauth_token = auth["oauth_token"]
oauth_token_secret = auth["oauth_token_secret"]
url = auth["auth_url"]
logger.info(url)
if myhardware.is_andrew_desktop or myhardware.is_andrew_macbook:
webbrowser.open(url)
oauth_verifier = input("Please enter your pin:")
twitter = Twython(app_key, app_secret, oauth_token, oauth_token_secret)
final_step = twitter.get_authorized_tokens(oauth_verifier)
final_key = final_step["oauth_token"]
final_secret = final_step["oauth_token_secret"]
dal.set_token("twitter final key " + screen_name, final_key)
dal.set_token("twitter final secret " + screen_name, final_secret)
tokens = [app_key, app_secret, final_key, final_secret]
return tokens
def __init__(self):
if settings.DEBUG:
self.twitter = TwitterDebugLogger()
else:
self.twitter = Twython(settings.CONSUMER_KEY,
settings.CONSUMER_SECRET,
settings.OAUTH_TOKEN,
settings.OAUTH_TOKEN_SECRET)
def postTwitter(tweet):
try:
twitter = Twython(CUSTOMER_KEY, CUSTOMER_SECRET, ACCESS_TOKEN,
ACCESS_TOKEN_SECRET)
twitter.update_status(status=tweet)
return 'Tweet posted!'
except Exception as e:
print e
return 'Check your internet connection.'
def generate_access_token(self):
auth = self.t.get_authentication_tokens()
print("Please go to {auth_url} for a verification code.".format(**auth))
verifier = input("Verification code: ")
twitter = Twython(self.consumer_token, self.consumer_secret, auth['oauth_token'], auth['oauth_token_secret'])
tokens = twitter.get_authorized_tokens(oauth_verifier=verifier)
return tokens['oauth_token'], tokens['oauth_token_secret']
def twitter_connect(request, apk):
# Twython Library https://github.com/ryanmcgrath/twython
twitter = Twython(settings.TWITTER_API_KEY, settings.TWITTER_API_SECRET)
auth = twitter.get_authentication_tokens(callback_url=request.build_absolute_uri(reverse('twitter_callback', args=[apk])))
request.session['TEMP_OAUTH_TOKEN'] = auth['oauth_token']
request.session['TEMP_OAUTH_TOKEN_SECRET'] = auth['oauth_token_secret']
return HttpResponseRedirect(auth['auth_url'])
def __init__(self):
if settings.DEBUG:
self.twitter = TwitterDebugLogger()
else:
self.twitter = Twython(
settings.CONSUMER_KEY,
settings.CONSUMER_SECRET,
settings.OAUTH_TOKEN,
settings.OAUTH_TOKEN_SECRET
)
def authenticate():
token_dir = "temp" + os.sep + "tokens" + os.sep
if not os.path.exists(token_dir):
os.makedirs(token_dir)
app_key_path = token_dir + "APP_KEY.pkl"
app_secret_path = token_dir + "APP_SECRET.pkl"
final_oauth_token_path = token_dir + "FINAL_OAUTH_TOKEN.pkl"
final_oauth_token_secret_path = token_dir + "FINAL_OAUTH_TOKEN_SECRET.pkl"
exists = os.path.isfile(app_key_path) and os.path.isfile(app_secret_path)
if exists:
app_key = pickle.load(open(app_key_path, "rb"))
app_secret = pickle.load(open(app_secret_path, "rb"))
else:
app_key = raw_input("Enter your APP_KEY:")
app_secret = raw_input("Enter your APP_SECRET:")
pickle.dump(app_key, open(app_key_path, "wb"))
pickle.dump(app_secret, open(app_secret_path, "wb"))
exists = os.path.isfile(final_oauth_token_path) and os.path.isfile(final_oauth_token_secret_path)
if exists:
final_oauth_token = pickle.load(open(final_oauth_token_path, "rb"))
final_oauth_token_secret = pickle.load(open(final_oauth_token_secret_path, "rb"))
else:
t = Twython(app_key, app_secret)
auth = t.get_authentication_tokens()
oauth_token = auth["oauth_token"]
oauth_token_secret = auth["oauth_token_secret"]
url = auth["auth_url"]
webbrowser.open(url)
oauth_verifier = raw_input("Enter your pin:")
t = Twython(app_key, app_secret, oauth_token, oauth_token_secret)
final_step = t.get_authorized_tokens(oauth_verifier)
final_oauth_token = final_step["oauth_token"]
final_oauth_token_secret = final_step["oauth_token_secret"]
pickle.dump(final_oauth_token, open(final_oauth_token_path, "wb"))
pickle.dump(final_oauth_token_secret, open(final_oauth_token_secret_path, "wb"))
return [app_key, app_secret, final_oauth_token, final_oauth_token_secret]
def __init__(self, user, *args, **kwargs):
self.user = user
self.social_token = SocialToken.objects.filter(
app__provider='twitter',
account__provider='twitter',
account__user=user)
self.social_app = SocialApp.objects.filter(
id=self.social_token.get().app.id)
self.twitter = Twython(self.social_app.get().client_id,
self.social_app.get().secret,
self.social_token.get().token,
self.social_token.get().token_secret)
self.twitter.verify_credentials()
class TwitterSingleton(metaclass=Singleton):
twitter = None
def __init__(self):
if settings.DEBUG:
self.twitter = TwitterDebugLogger()
else:
self.twitter = Twython(settings.CONSUMER_KEY,
settings.CONSUMER_SECRET,
settings.OAUTH_TOKEN,
settings.OAUTH_TOKEN_SECRET)
def status_update_hooks(self):
pass
def tweet(self, status, *args, **kwargs):
try:
self.twitter.update_status(status=status, *args, **kwargs)
self.status_update_hooks()
except TwythonError as e:
log("Twython error, tweeting: {0}".format(e))
def reply_to(self, tweet_data, status, *args, **kwargs):
status = '@{0} {1}'.format(tweet_data['user']['screen_name'], status)
self.tweet(status=status,
in_reply_to_status_id=tweet_data['id_str'],
*args,
**kwargs)
def update_status_with_media(self, status, media, in_reply_to_status_id):
'''
:param status:
:param media: is simply the un-uploaded media
:param in_reply_to:
:return:
'''
try:
log('blah blaaeouaoeuh')
response = self.twitter.upload_media(media=media)
log('blah blah')
self.twitter.update_status(
status=status,
media_ids=[response['media_id']],
in_reply_to_status_id=in_reply_to_status_id)
self.status_update_hooks()
except TwythonError as e:
log("Twython error, updating status with media: {0}".format(e))
def send_direct_message(self, text, user_id=None, screen_name=None):
if user_id:
self.twitter.send_direct_message(text=text, user_id=user_id)
elif screen_name:
self.twitter.send_direct_message(text=text,
screen_name=screen_name)
def twitter_callback(request, apk):
if('oauth_verifier' in request.GET):
oauth_verifier = request.GET['oauth_verifier']
twitter = Twython(settings.TWITTER_API_KEY, settings.TWITTER_API_SECRET,
request.session['TEMP_OAUTH_TOKEN'], request.session['TEMP_OAUTH_TOKEN_SECRET'])
final_auth = twitter.get_authorized_tokens(oauth_verifier)
request.session['OAUTH_TOKEN'] = final_auth['oauth_token']
request.session['OAUTH_TOKEN_SECRET'] = final_auth['oauth_token_secret']
activity = Activity.objects.get(pk=apk)
sendDefinitiveMessage(request, apk)
return redirect(reverse('mg_edit', args=[activity.meetupGroup.id]))
def del_jobpost_tw(user, post):
user = User.objects.filter(id=user).first()
if user:
user_twitter = Twitter.objects.filter(user=user).first()
twitter = Twython(settings.TW_APP_KEY, settings.TW_APP_SECRET,
user_twitter.oauth_token, user_twitter.oauth_secret)
try:
twitter.destroy_status(id=post.post_id)
post = TwitterPost.objects.filter(id=post)
post.delete()
except:
print("not deleted")
else:
return "connect to twitter"
def sendDefinitiveMessage(request, apk):
if 'OAUTH_TOKEN' not in request.session or 'OAUTH_TOKEN_SECRET' not in request.session:
return twitter_connect(request, apk)
twitter = Twython(settings.TWITTER_API_KEY, settings.TWITTER_API_SECRET,
request.session['OAUTH_TOKEN'], request.session['OAUTH_TOKEN_SECRET'])
logger.error(twitter);
activity = Activity.objects.get(pk=apk )
twitter.update_status( status= 'Activity ' + activity.name + ' is now definitive '
', activity starts at ' + activity.startDate.strftime("%d.%m.%Y") + ' in ' + activity.location )
return None
class Twitter:
"""
Encapsulates the Twython lib for
isolation and maintainability
"""
TWITTER_APP_KEY = '???'
TWITTER_APP_KEY_SECRET = '???'
TWITTER_ACCESS_TOKEN = '???'
TWITTER_ACCESS_TOKEN_SECRET = '???'
tweets = None
api = None
def __init__(self):
self.api = Twython(app_key=self.TWITTER_APP_KEY,
app_secret=self.TWITTER_APP_KEY_SECRET,
oauth_token=self.TWITTER_ACCESS_TOKEN,
oauth_token_secret=self.TWITTER_ACCESS_TOKEN_SECRET)
def search(self, word):
""" Looks up the word as Twitter hashtag"""
search = self.api.search(q='#' + word, count=5)
return search['statuses']
class TwitterSingleton(metaclass=Singleton):
twitter = None
def __init__(self):
if settings.DEBUG:
self.twitter = TwitterDebugLogger()
else:
self.twitter = Twython(
settings.CONSUMER_KEY,
settings.CONSUMER_SECRET,
settings.OAUTH_TOKEN,
settings.OAUTH_TOKEN_SECRET
)
def status_update_hooks(self):
pass
def tweet(self, status, *args, **kwargs):
try:
self.twitter.update_status(status=status, *args, **kwargs)
self.status_update_hooks()
except TwythonError as e:
log("Twython error, tweeting: {0}".format(e))
def reply_to(self, tweet_data, status, *args, **kwargs):
status = '@{0} {1}'.format(tweet_data['user']['screen_name'], status)
self.tweet(status=status, in_reply_to_status_id=tweet_data['id_str'], *args, **kwargs)
def update_status_with_media(self, status, media, in_reply_to_status_id):
'''
:param status:
:param media: is simply the un-uploaded media
:param in_reply_to:
:return:
'''
try:
log('blah blaaeouaoeuh')
response = self.twitter.upload_media(media=media)
log('blah blah')
self.twitter.update_status(status=status, media_ids=[response['media_id']],
in_reply_to_status_id=in_reply_to_status_id)
self.status_update_hooks()
except TwythonError as e:
log("Twython error, updating status with media: {0}".format(e))
def send_direct_message(self, text, user_id=None, screen_name=None):
if user_id:
self.twitter.send_direct_message(text=text, user_id=user_id)
elif screen_name:
self.twitter.send_direct_message(text=text, screen_name=screen_name)
def run(self, args):
# configure the server port for the callback
serverPort = 8000
# initiate OAuth workflow
twitter = Twython(args.twitter_app_key, args.twitter_app_secret)
# step 1
self._log.info("Initiating Twitter OAuth workflow.")
oAuth = twitter.get_authentication_tokens(callback_url="http://localhost:%d/callback" % (serverPort))
oAuthToken = oAuth['oauth_token']
oAuthTokenSecret = oAuth['oauth_token_secret']
# step 2
webbrowser.open_new(oAuth['auth_url'])
# step 3
self._log.info("Starting OAuth HTTP callback handler.")
httpd = OAuthCallbackServer(('', serverPort), self._log, Twython(args.twitter_app_key, args.twitter_app_secret, oAuthToken, oAuthTokenSecret))
httpd.handle_request()
def __init__(self, user, *args, **kwargs):
self.user = user
self.social_token = SocialToken.objects.filter(app__provider='twitter',
account__provider='twitter',
account__user=user)
self.social_app = SocialApp.objects.filter(id=self.social_token.get().app.id)
self.twitter = Twython(self.social_app.get().client_id, self.social_app.get().secret,
self.social_token.get().token,
self.social_token.get().token_secret)
self.twitter.verify_credentials()
class AuthorizedTwitter:
def __init__(self, consumer_token, consumer_secret, access_token, secret):
self.t = Twython(consumer_token, consumer_secret, access_token, secret)
def get_list(self, name):
lists = self.t.show_owned_lists()
l = next((l for l in lists['lists'] if l['name'] == name), None)
if not l:
l = self.t.create_list(name=name, mode='private')
return l
def add_missing_members(self, tw_list, members):
list_id = tw_list['id']
current_members = self.t.get_list_members(list_id=list_id)
current_member_names = set([u['screen_name'].lower() for u in current_members['users']])
missing_members = members - current_member_names
self.t.create_list_members(list_id=list_id, screen_name=",".join(missing_members))
return missing_members
def authenticate():
token_dir = "temp" + os.sep + "tokens" + os.sep
if not os.path.exists(token_dir):
os.makedirs(token_dir)
app_key_path = token_dir + "APP_KEY.pkl"
app_secret_path = token_dir + "APP_SECRET.pkl"
final_oauth_token_path = token_dir + "FINAL_OAUTH_TOKEN.pkl"
final_oauth_token_secret_path = token_dir + "FINAL_OAUTH_TOKEN_SECRET.pkl"
exists = os.path.isfile(app_key_path) and os.path.isfile(app_secret_path)
if exists:
app_key = pickle.load(open(app_key_path, "rb"))
app_secret = pickle.load(open(app_secret_path, "rb"))
else:
app_key = raw_input("Enter your APP_KEY:")
app_secret = raw_input("Enter your APP_SECRET:")
pickle.dump(app_key, open(app_key_path, "wb"))
pickle.dump(app_secret, open(app_secret_path, "wb"))
exists = os.path.isfile(final_oauth_token_path) and os.path.isfile(
final_oauth_token_secret_path)
if exists:
final_oauth_token = pickle.load(open(final_oauth_token_path, "rb"))
final_oauth_token_secret = pickle.load(
open(final_oauth_token_secret_path, "rb"))
else:
t = Twython(app_key, app_secret)
auth = t.get_authentication_tokens()
oauth_token = auth["oauth_token"]
oauth_token_secret = auth["oauth_token_secret"]
url = auth["auth_url"]
webbrowser.open(url)
oauth_verifier = raw_input("Enter your pin:")
t = Twython(app_key, app_secret, oauth_token, oauth_token_secret)
final_step = t.get_authorized_tokens(oauth_verifier)
final_oauth_token = final_step["oauth_token"]
final_oauth_token_secret = final_step["oauth_token_secret"]
pickle.dump(final_oauth_token, open(final_oauth_token_path, "wb"))
pickle.dump(final_oauth_token_secret,
open(final_oauth_token_secret_path, "wb"))
return [app_key, app_secret, final_oauth_token, final_oauth_token_secret]
class Twitter:
def __init__(self, consumer_token, consumer_secret):
self.t = Twython(consumer_token, consumer_secret)
self.consumer_token = consumer_token
self.consumer_secret = consumer_secret
def generate_access_token(self):
auth = self.t.get_authentication_tokens()
print("Please go to {auth_url} for a verification code.".format(**auth))
verifier = input("Verification code: ")
twitter = Twython(self.consumer_token, self.consumer_secret, auth['oauth_token'], auth['oauth_token_secret'])
tokens = twitter.get_authorized_tokens(oauth_verifier=verifier)
return tokens['oauth_token'], tokens['oauth_token_secret']
def authenticate(self, access_token, secret):
return AuthorizedTwitter(self.consumer_token, self.consumer_secret, access_token, secret)
class TwitterSingleton(metaclass=Singleton):
twitter = None
def __init__(self):
if settings.DEBUG:
self.twitter = TwitterDebugLogger()
else:
self.twitter = Twython(
settings.CONSUMER_KEY,
settings.CONSUMER_SECRET,
settings.OAUTH_TOKEN,
settings.OAUTH_TOKEN_SECRET
)
def status_update_hooks(self):
pass
def tweet(self, status, *args, **kwargs):
try:
self.twitter.update_status(status=status, *args, **kwargs)
self.status_update_hooks()
except TwythonError as e:
log("Twython error, tweeting: {0}".format(e))
def reply_to(self, tweet_data, status, *args, **kwargs):
status = '@{0} {1}'.format(tweet_data['user']['screen_name'], status)
self.tweet(status=status, in_reply_to_status_id=tweet_data['id_str'], *args, **kwargs)
def update_status_with_media(self, *args, **kwargs):
try:
self.twitter.update_status_with_media(*args, **kwargs)
self.status_update_hooks()
except TwythonError as e:
log("Twython error, updating status with media: {0}".format(e))
def send_direct_message(self, text, user_id=None, screen_name=None):
if user_id:
self.twitter.send_direct_message(text=text, user_id=user_id)
elif screen_name:
self.twitter.send_direct_message(text=text, screen_name=screen_name)
def twitter_login(request):
if "oauth_verifier" in request.GET:
oauth_verifier = request.GET["oauth_verifier"]
twitter = Twython(
settings.PJ_TW_APP_KEY,
settings.PJ_TW_APP_SECRET,
request.session["OAUTH_TOKEN"],
request.session["OAUTH_TOKEN_SECRET"],
)
final_step = twitter.get_authorized_tokens(oauth_verifier)
if not final_step.get("oauth_token_secret"):
return render(
request,
"404.html",
{
"message": "Sorry, Your session has been expired",
"reason": "Please kindly try again to update your profile",
"email": settings.DEFAULT_FROM_EMAIL,
"number": settings.CONTACT_NUMBER,
},
status=404,
)
twitter = Twython(
settings.PJ_TW_APP_KEY,
settings.PJ_TW_APP_SECRET,
final_step["oauth_token"],
final_step["oauth_token_secret"],
)
followers = twitter.get_followers_list(
screen_name=final_step["screen_name"])
friends = twitter.get_friends_list(
screen_name=final_step["screen_name"])
if not request.user.is_tw_connected and request.user.is_authenticated:
Twitter.objects.create(
user=request.user,
twitter_id=final_step.get("user_id", ""),
screen_name=final_step.get("screen_name", ""),
oauth_token=final_step.get("oauth_token", ""),
oauth_secret=final_step.get("oauth_token_secret", ""),
)
add_twitter_friends_followers.delay(request.user.id, friends,
followers)
if request.is_mobile == "mobile":
return HttpResponseRedirect("/jobs/")
if request.session.get("job_id"):
log_apply = login_and_apply(request)
if log_apply:
return HttpResponseRedirect(log_apply[0].slug + "?job_apply=" +
log_apply[1])
return HttpResponseRedirect(reverse("my:profile"))
else:
twitter = Twython(settings.PJ_TW_APP_KEY, settings.PJ_TW_APP_SECRET)
url = (request.scheme + "://" + request.META["HTTP_HOST"] +
reverse("social:twitter_login"))
auth = twitter.get_authentication_tokens(callback_url=url)
request.session["OAUTH_TOKEN"] = auth["oauth_token"]
request.session["OAUTH_TOKEN_SECRET"] = auth["oauth_token_secret"]
return HttpResponseRedirect(auth["auth_url"])
class TwitterAdapter(MessageProvider, ImageProvider, ActionMessageProvider):
id = 'twitter'
name = 'TwitterAdapter'
def __init__(self, user, *args, **kwargs):
self.user = user
self.social_token = SocialToken.objects.filter(
app__provider='twitter',
account__provider='twitter',
account__user=user)
self.social_app = SocialApp.objects.filter(
id=self.social_token.get().app.id)
self.twitter = Twython(self.social_app.get().client_id,
self.social_app.get().secret,
self.social_token.get().token,
self.social_token.get().token_secret)
self.twitter.verify_credentials()
def publish_image(self, image, message='', **kwargs):
img = open(image.path).read()
try:
logger.info(
'try to update twitter status with an image, for user: %s ' %
self.user)
result = self.twitter.update_status_with_media(status=message,
media=StringIO(img))
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def publish_message(self, message, **kwargs):
"""
Attachment:
{"name": "Link name"
"link": "http://www.example.com/",
"caption": "{*actor*} posted a new review",
"description": "This is a longer description of the attachment",
"picture": picture}
"""
try:
logger.info('try to update twitter status, for user: %s ' %
self.user)
attachment = kwargs.pop('attachment', {})
message = message or attachment.get(
'caption', attachment.get('description', ''))
full_message = "%s (%s)" % (message, attachment.get('link')
) if 'link' in attachment else message
if 'picture' in attachment:
img = open(attachment.get('picture').path).read()
result = self.twitter.update_status_with_media(
status=full_message, media=StringIO(img))
else:
result = self.twitter.update_status(status=full_message)
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def publish_action_message(self, message, action_info, **kwargs):
"""
action_info: dictionary with information about the corresponding app activity/action
{
"link": the url for the app activity/action to point to,
"actor": the actor,
"action": the action performed by 'actor',
"verb": the verbal form to show for the action performed by 'actor',
"target": the target of the action,
"app": the application name,
"domain": the application domain
"picture": the picture to show
}
"""
try:
logger.info('try to update twitter status, for user: %s ' %
self.user)
from django.utils.translation import ugettext as _
message = message or "%s (%s) %s %s" % (
action_info.get('action', ''), action_info.get('target', ''),
_(u'using'), action_info.get('app', _(u'application'))),
full_message = "%s (%s)" % (message, action_info.get('link')
) if 'link' in action_info else message
if 'picture' in action_info:
img = open(action_info.get('picture').path).read()
result = self.twitter.update_status_with_media(
status=full_message, media=StringIO(img))
else:
result = self.twitter.update_status(status=full_message)
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def __init__(self, consumer_token, consumer_secret, access_token, secret):
self.t = Twython(consumer_token, consumer_secret, access_token, secret)
class TwitterAdapter(MessageProvider, ImageProvider, ActionMessageProvider):
id = 'twitter'
name = 'TwitterAdapter'
def __init__(self, user, *args, **kwargs):
self.user = user
self.social_token = SocialToken.objects.filter(app__provider='twitter',
account__provider='twitter',
account__user=user)
self.social_app = SocialApp.objects.filter(id=self.social_token.get().app.id)
self.twitter = Twython(self.social_app.get().client_id, self.social_app.get().secret,
self.social_token.get().token,
self.social_token.get().token_secret)
self.twitter.verify_credentials()
def publish_image(self, image, message='', **kwargs):
img = open(image.path).read()
try:
logger.info('try to update twitter status with an image, for user: %s ' % self.user)
result = self.twitter.update_status_with_media(status=message, media=StringIO(img))
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def publish_message(self, message, **kwargs):
"""
Attachment:
{"name": "Link name"
"link": "http://www.example.com/",
"caption": "{*actor*} posted a new review",
"description": "This is a longer description of the attachment",
"picture": picture}
"""
try:
logger.info('try to update twitter status, for user: %s ' % self.user)
attachment = kwargs.pop('attachment', {})
message = message or attachment.get('caption', attachment.get('description', ''))
full_message = "%s (%s)" % (message, attachment.get('link')) if 'link' in attachment else message
if 'picture' in attachment:
img = open(attachment.get('picture').path).read()
result = self.twitter.update_status_with_media(status=full_message, media=StringIO(img))
else:
result = self.twitter.update_status(status=full_message)
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def publish_action_message(self, message, action_info, **kwargs):
"""
action_info: dictionary with information about the corresponding app activity/action
{
"link": the url for the app activity/action to point to,
"actor": the actor,
"action": the action performed by 'actor',
"verb": the verbal form to show for the action performed by 'actor',
"target": the target of the action,
"app": the application name,
"domain": the application domain
"picture": the picture to show
}
"""
try:
logger.info('try to update twitter status, for user: %s ' % self.user)
from django.utils.translation import ugettext as _
message = message or "%s (%s) %s %s" % (
action_info.get('action', ''),
action_info.get('target', ''),
_(u'using'),
action_info.get('app', _(u'application'))
),
full_message = "%s (%s)" % (message, action_info.get('link')) if 'link' in action_info else message
if 'picture' in action_info:
img = open(action_info.get('picture').path).read()
result = self.twitter.update_status_with_media(status=full_message, media=StringIO(img))
else:
result = self.twitter.update_status(status=full_message)
logger.debug(str(result))
return result
except Exception as e:
logger.error(e)
raise e
def __init__(self, consumer_token, consumer_secret):
self.t = Twython(consumer_token, consumer_secret)
self.consumer_token = consumer_token
self.consumer_secret = consumer_secret
def __init__(self):
self.api = Twython(app_key=self.TWITTER_APP_KEY,
app_secret=self.TWITTER_APP_KEY_SECRET,
oauth_token=self.TWITTER_ACCESS_TOKEN,
oauth_token_secret=self.TWITTER_ACCESS_TOKEN_SECRET)
if f:
f.close()
def tweet(text=None, media_id=None, in_reply_to_status_id=None):
media_ids = None
if media_id:
media_ids = [media_id]
twitter.update_status(status=text,
media_ids=media_ids,
in_reply_to_status_id=in_reply_to_status_id)
tokens = authenticate()
twitter = Twython(app_key=tokens[0],
app_secret=tokens[1],
oauth_token=tokens[2],
oauth_token_secret=tokens[3])
stream = MyStreamer(app_key=tokens[0],
app_secret=tokens[1],
oauth_token=tokens[2],
oauth_token_secret=tokens[3])
camera = cv2.VideoCapture(0)
take_photo()
def start():
start_schedule()
start_stream()
