class Tweet():
def __init__(self):
""" Get twitter configuration and create the twitter Api
"""
### load the json to get twitter config
# check if the file exists
if os.path.isfile(CONFIG_FILE):
tmp_json = json.load(open(CONFIG_FILE))
# test if tweeting is enabled or not....
if not tmp_json['twitter']['enable']:
print("We don't want to tweet!")
return
consumer_key = tmp_json['twitter']['consumer_key']
consumer_secret = tmp_json['twitter']['consumer_secret']
access_token_key = tmp_json['twitter']['access_token']
access_token_secret = tmp_json['twitter']['access_token_secret']
else:
raise Exception(
"Twitter oauth configuration : unable to open or read file '{0}')"
.format(CONFIG_FILE))
return
### Connect to twitter
try:
self.api = Api(consumer_key=consumer_key,
consumer_secret=consumer_secret,
access_token_key=access_token,
access_token_secret=access_token_secret)
self.api.VerifyCredentials()
except TwitterError:
raise Exception(
"Unable to log in the twitter account : {0}".format(
traceback.format_exc()))
def publish(self, message, nb_try=0):
""" Just tweet
"""
try:
status = self.api.PostUpdate(message)
except TwitterError as e:
# duplicate message error...
# let's try to add some random data at the end
if e[0][0]['code'] == 187:
if nb_try == 0:
message_addon = "Enjoy."
elif nb_try == 1:
message_addon = "Have fun."
elif nb_try == 2:
message_addon = ":)"
elif nb_try == 3:
message_addon = ";)"
elif nb_try == 4:
message_addon = ":D"
else:
raise Exception(
"Too much duplicates for this message (3)....")
new_message = "{0}. {1}".format(message, message_addon)
self.publish(new_message, nb_try + 1)
except:
print("Unable to tweet : {0}".format(traceback.format_exc()))
def get_official(cls) -> '_ApiOfficial':
api = TwitterApi(consumer_key=Config.CONSUMER_KEY,
consumer_secret=Config.CONSUMER_SECRET,
access_token_key=Config.ACCESS_TOKEN,
access_token_secret=Config.ACCESS_TOKEN_SECRET)
api.VerifyCredentials()
return _ApiOfficial(api)
class TokenInfo:
'''
This class stores the data in order to connect to twitter
'''
def __init__(self, consumer_key, consumer_secret, access_token_key,
access_token_secret):
'''
@param
All consumers are strings
'''
self.consumer_key = consumer_key
self.consumer_secret = consumer_secret
self.access_token_key = access_token_key
self.access_token_secret = access_token_secret
self.api = None
def __str__(self):
return ("Consumer key: " + str(self.consumer_key) + "\n" + \
"Consumer secret: " + str(self.consumer_secret) + "\n" + \
"Access Token Key: " + str(self.access_token_key) + "\n" + \
"Access Token Secret : " + str(self.access_token_secret) + "\n")
def connect_api(self):
'''
Connects the api with the given cesidentials
'''
self.api = Api(consumer_key=self.consumer_key,
consumer_secret=self.consumer_secret,
access_token_key=self.access_token_key,
access_token_secret=self.access_token_secret)
#Our try/catch given to us by twitter api
self.api.VerifyCredentials()
def get_tweets(screen_name, limit):
api = Api(consumer_key=app.config['CONSUMER_KEY'],
consumer_secret=app.config['CONSUMER_SECRET'],
access_token_key=app.config['ACCESS_TOKEN_KEY'],
access_token_secret=app.config['ACCESS_TOKEN_SECRET'])
api.VerifyCredentials()
tweets = api.GetUserTimeline(screen_name=screen_name, count=limit)
include_tweets(screen_name, tweets)
return database.tweets.find()
class Main(Task):
defaults = {
'consumer_key': None,
'consumer_secret': None,
'access_token_key': None,
'access_token_secret': None,
'disable_cache': True,
'output': 'ALL',
'update_freq': 45,
'tweet_format':
u'>> tweet from {tweet.user.screen_name}: {tweet.text_clean} <<',
'err_announce': True,
'err_announce_freq': timedelta(hours=8).total_seconds(),
'soft_limit': 10,
}
_setting_prefix = 'TWITTER_'
log = property(lambda s: s.madcow.log)
def __new__(cls, *args, **opts):
obj = super(Main, cls).__new__(cls, *args, **opts)
obj.ready = False
return obj
def init(self):
opts = {}
for key, default in self.defaults.iteritems():
setting = self._setting_prefix + key.upper()
val = getattr(settings, setting, None)
if val is None:
val = default
opts[key] = val
x, y = tee(
imap(
'{}_{}'.format,
*izip(*product(['consumer', 'access_token'],
['key', 'secret']))))
self.api = Api(**dict(izip(x, imap(opts.pop, y))))
if opts.pop('disable_cache'):
self.api.SetCache(None)
self.last_error_announce = 0
self.last_id = None
vars(self).update(opts)
try:
status = self.api.VerifyCredentials()
except TwitterError, exc:
exc_info = sys.exc_info()
error = APIError.from_twitter_error(exc)
self.log.error('twitter oAuth2 failure, disabling task: {}'.format(
error.message))
self.unload()
reraise(*exc_info)
else:
def get_tweets(screen_name, limit):
api = Api(consumer_key=app.config['CONSUMER_KEY'],
consumer_secret=app.config['CONSUMER_SECRET'],
access_token_key=app.config['ACCESS_TOKEN_KEY'],
access_token_secret=app.config['ACCESS_TOKEN_SECRET'])
api.VerifyCredentials()
tweets = api.GetUserTimeline(screen_name=screen_name, count=limit)
for tweet in tweets:
tweet.url = 'https://twitter.com/{}/statuses/{}'.format(
screen_name, tweet.id)
return tweets
def twitter(self, service_id, post_id, post_url):
try:
service = ServiceSubscribe.query.filter_by(
service_subscribe_id=service_id, alive=True).one()
post = Post.query.filter_by(post_id=post_id).one()
api = Api(service.credentials['consumer_key'],
service.credentials['consumer_secret'],
service.credentials['access_token_key'],
service.credentials['access_token_secret'])
if api.VerifyCredentials():
api.PostDirectMessage('{}\n{}'.format(post.title, post_url))
else:
service.alive = False
db.session.commit()
except NoResultFound:
pass
except (SQLAlchemyError, TwitterError) as e:
logger.exception('twitter')
raise self.retry(exc=e,
countdown=self.default_retry_delay *
(self.request.retries + 1))
class TwitterLog:
DEBUG = 10
INFO = 20
WARNING = 30
ERROR = 40
CRITICAL = 50
def __init__(self,
consumer_key,
consumer_secret,
access_key,
access_secret,
log_level=None):
self.log_level = log_level or self.INFO
self.api = Api(consumer_key, consumer_secret, access_key,
access_secret)
if not self.api.VerifyCredentials():
raise ValueError(
"Could not log in to Twitter with the keys provided.")
def debug(self, message):
self.log(message, self.DEBUG)
def info(self, message):
self.log(message, self.INFO)
def warning(self, message):
self.log(message, self.WARNING)
def error(self, message):
self.log(message, self.ERROR)
def critical(self, message):
self.log(message, self.CRITICAL)
def log(self, message, level):
"Post the first 140 characters if the level is at least the log level"
if level >= self.log_level:
self.api.PostUpdate(message[:140])
class Moody:
"""
Enables moody_py Twitter functionality by using python-twitter wrapper for Twitter API.
"""
def __init__(self):
"""
Initializes python-twitter wrapper with the Twitter API credentials
"""
self.api = Api(consumer_key=credentials["consumer_key"],
consumer_secret=credentials["consumer_secret"],
access_token_key=credentials["access_token_key"],
access_token_secret=credentials["access_token_secret"])
def verify_credentials(self):
"""
Verifies if the given tokens are valid
:return: A boolean value stating if the credentials are valid
"""
try:
self.api.VerifyCredentials()
logging.info('Successfully verified')
return True
except TwitterError as e:
logging.error('Error verifying credentials: %s',
e.message[0]['message'])
return False
def tweet(self, twitter_post, instruction):
"""
Posts a twit on the moody_py account
:param twitter_post: TwitterPost object containing relevant twit information
:param instruction: models.Instruction what kind of tweet to post
:return: TwitterResponse: Twitter response object.
"""
if instruction is None:
logging.error('Instruction parameter missing')
return TwitterResponse(description='Instruction parameter missing')
if instruction == Instruction.PROCESS_WEATHER_DATA:
twit_content = "{}, {} {} C {}".format(twitter_post.post_text,
twitter_post.condition,
twitter_post.temperature,
twitter_post.youtube_url)
if instruction == Instruction.PROCESS_ARTIST:
twit_content = "Requested: {} {}".format(twitter_post.post_text,
twitter_post.youtube_url)
if instruction == Instruction.PROCESS_INSTAGRAM_POST:
twit_content = twitter_post.post_text
if twitter_post.post_text is None or twitter_post.youtube_url is None:
return TwitterResponse(
description='Twitter post text or youtube_url not resolved!')
try:
status = self.api.PostUpdate(twit_content)
logging.info('Posted twit with status: %s', status)
return TwitterResponse(status)
except TwitterError as e:
logging.error('Error posting twit: %s', e.message[0]['message'])
return TwitterResponse(
description='Fatal error while posting tweet')
TWITTER_DELAY_ON_RATE_LIMIT = 930
engine = sqlalchemy.create_engine("postgresql://" + DB_USER + ":" + DB_PASS +
"@" + DB_HOST + '/' + DB_DB)
account_activity = [
'id', 'screen_name', 'list_slug', 'created_at', 'last_activity'
]
df_accounts = pd.DataFrame(columns=account_activity)
api = Api(TWITTER_CONSUMER_API_KEY, TWITTER_CONSUMER_API_SECRET_KEY,
TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET)
try:
user_data = api.VerifyCredentials()
except TwitterError as e:
print(e.message[0]['message'], e.message[0]['code'])
if e.message[0]['code'] == 88:
for x in range(0, TWITTER_DELAY_ON_RATE_LIMIT):
print(x, end='\r')
sleep(1)
user_data = api.VerifyCredentials()
if e.message[0]['code'] == 32:
sys.exit() # or return
user_id = user_data.id
try:
class TwitterClientImpl(object):
TWT_FMT = 'https://twitter.com/{}/status/{}'
URL_LOC = 'https://t.co'
REQUIRED_CONFIG_PARAMS = [
'consumer_key', 'consumer_secret', 'access_token',
'access_token_secret', 'handle', 'name'
]
OPTIONAL_CONFIG_PARAMS = [
['sleep_on_rate_limit', True],
['last_id', None],
['ignore_rts', True],
['content', 'text'],
['limit', 10],
]
def __init__(self, **kargs):
self.api = None
self.last_id = None
self.ignore_rts = True
for k in self.REQUIRED_CONFIG_PARAMS:
setattr(self, k, kargs.get(k))
for k, v in self.OPTIONAL_CONFIG_PARAMS:
setattr(self, k, kargs.get(k, v))
# print "lastid= %s" % str(self.last_id)
def consume(self):
_handle = self.handle if self.handle[0] == '@' else '@' + self.handle
msgs = []
tweets = []
keep_going = False
try:
keep_going = self.test_source()
except:
logging.debug(
'Failed to retrieve posts with the following exception:\n{}'.
format(traceback.format_exc()))
try:
if self.api is not None:
self.api = None
keep_going = self.test_source()
except:
logging.debug(
'Failed to retrieve posts with the following exception:\n{}'
.format(traceback.format_exc()))
if not keep_going:
return msgs
try:
tweets = self.api.GetUserTimeline(screen_name=_handle,
count=self.limit,
since_id=self.last_id)
except:
logging.debug(
'Failed to retrieve posts with the following exception:\n{}'.
format(traceback.format_exc()))
for p in tweets:
js = {}
if p.text.startswith('RT') and self.ignore_rts:
# Ignore retweets
continue
if self.last_id is None or \
long(p.id) > long(self.last_id):
self.last_id = str(p.id)
js['meta'] = p.AsDict()
js['tm_id'] = js['meta']['id']
js['references'] = [
self.TWT_FMT.format(self.handle, p.id),
]
js['link'] = self.TWT_FMT.format(self.handle, p.id)
js['timestamp'] = parsedate_to_datetime(p.created_at)
js['obtained_timestamp'] = datetime.utcnow().strftime(
"%Y-%m-%d %H:%M:%S")
if self.content is None or self.content not in js['meta']:
js['content'] = json.dumps(p.AsDict())
js['forced_content'] = True
# \/ for internal debugging (this does not JSON dump)
# js['raw'] = p
else:
js['content'] = getattr(p, self.content)
# \/ for internal debugging (this does not JSON dump)
js['forced_content'] = False
js['source'] = self.name
js['source_type'] = 'twitter'
js['user'] = self.handle.strip('@')
msgs.append(Message(js))
return msgs
def test_source(self):
if self.api is None:
w = self.sleep_on_rate_limit
self.api = Api(self.consumer_key,
self.consumer_secret,
self.access_token,
self.access_token_secret,
sleep_on_rate_limit=w)
if self.api is None:
raise Exception("Unable to connect to twitter")
return self.api.VerifyCredentials()
tweet_list = []
for tweet in sys.argv[1:]:
tweet_list += make_tweet_list(tweet)
if not tweet_list:
tweet_list = pop_a_tweet()
#"""
if tweet_list:
print 'Attempting Twitter Api Login...'
Twitter = TwitterApi(
consumer_key=CREDENTIALS.get("consumer_key"),
consumer_secret=CREDENTIALS.get("consumer_secret"),
access_token_key=CREDENTIALS.get("access_token_key"),
access_token_secret=CREDENTIALS.get("access_token_secret")
)
ME = Twitter.VerifyCredentials().screen_name
print "Current user is @" + ME
if tweet_list[0] == '-g':
user_list = tweet_list[1:]
if user_list:
for user in user_list:
print
print "Recent tweets from " + user + ":"
print "===================" + "=" * (len(user) + 1)
tweets = Twitter.GetUserTimeline(user[1:])
#count = 0
for tweet in tweets:
#if count == 5: break;
print "$", tweet.text
#count += 1
else:
def callback(request, direction):
if not direction in ('do', 'seek'):
raise Http404('Direction not understood')
from twitter import Api
result = auth.callback(
getattr(settings, '%s_TWITTER_CONSUMER_KEY' % direction.upper()),
getattr(settings, '%s_TWITTER_CONSUMER_SECRET' % direction.upper()),
request)
key = '%ser' % direction
if not result:
return HttpResponseRedirect('/')
api = Api(getattr(settings, '%s_TWITTER_CONSUMER_KEY' % direction.upper()),
getattr(settings,
'%s_TWITTER_CONSUMER_SECRET' % direction.upper()),
access_token_key=result.key,
access_token_secret=result.secret)
request.session['twitter'] = {'key': result.key, 'secret': result.secret}
user = api.VerifyCredentials()
details = request.session.pop(key, {})
try:
profile = Profile.objects.get(username__iexact=user.screen_name)
except Profile.DoesNotExist:
profile = Profile(username=user.screen_name.lower())
profile.description = user.description
profile.url = user.url
postcode, created = Postcode.objects.get_or_create(
postcode=details.get('postcode'))
profile.postcode = postcode
profile.save()
skill_names = details.get('skills', [])
added_skills = []
if direction == 'do':
skill_qs = profile.has_skills
else:
skill_qs = profile.required_skills
for name in skill_names:
slug = slugify(name)
try:
skill = Skill.objects.get(slug=slug)
except Skill.DoesNotExist:
skill = Skill.objects.create(name=name, slug=slug)
if direction == 'do':
skill_qs.add(skill)
else:
skill_qs.add(skill)
added_skills.append(skill.pk)
skill_qs.exclude(pk__in=added_skills).delete()
skill_list = [
'#' + skill.slug.replace('-', '').replace('_', '')
for skill in skill_qs.all()
]
if len(skill_list) > 1:
skill_list = '%s or %s' % (', '.join(skill_list[0:-1]), skill_list[-1])
else:
skill_list = skill_list[0]
if direction == 'do':
patterns = (
'Contact @%(username)s if you need %(skill_list)s: %(url)s',
'If you need %(skill_list)s, find @%(username)s: %(url)s',
'Need %(skill_list)s? Get in touch with @%(username)s: %(url)s',
'.@%(username)s can do %(skill_list)s. @%(username)s: %(url)s')
else:
patterns = (
'Contact @%(username)s if you can do %(skill_list)s: %(url)s',
'If you can do %(skill_list)s, find @%(username)s: %(url)s',
'Freelancer with %(skill_list)s experience? Contact @%(username)s: %(url)s',
'.@%(username)s needs %(skill_list)s: %(url)s')
tweet = random.choice(patterns) % {
'username': profile.username,
'skill_list': skill_list,
'url': 'http://idoxiny.com%s' % profile.get_absolute_url()
}
auth.tweet(tweet)
auth.follow(profile.username)
return HttpResponseRedirect(profile.get_absolute_url())
class TwitterApi:
DESTROY_STATUS_ENDPOINT = "https://api.twitter.com/1.1/statuses/destroy/:id.json"
DESTROY_FAVORITE_ENDPOINT = "https://api.twitter.com/1.1/favorites/destroy.json"
# Rate limit per 15 minutes window # TODO use a queue
POST_DIRECT_MESSAGE_RATE_LIMIT = 10
# Maximum amount of friendships we can look at with "GET friendships/lookup"
MAX_AMOUNT_FRIENDSHIPS_LOOKUP = 100
def __init__(self, twitter_credentials):
try:
self.username = twitter_credentials["username"]
# python-twitter
self.api = Api(
consumer_key=twitter_credentials["consumer_key"],
consumer_secret=twitter_credentials["consumer_secret"],
access_token_key=twitter_credentials["access_token"],
access_token_secret=twitter_credentials["access_token_secret"])
# tweepy
auth = tweepy.OAuthHandler(twitter_credentials["consumer_key"],
twitter_credentials["consumer_secret"])
auth.set_access_token(twitter_credentials["access_token"],
twitter_credentials["access_token_secret"])
self.tweepy_api = tweepy.API(auth)
except KeyError as key_error:
logging.critical(
"Invalid \"twitter_credentials\" argument: {}".format(
key_error.args[0]))
raise
except TypeError as type_error:
logging.critical(
"Incorrect \"twitter_credentials\" argument: {}".format(
type_error.args[0]))
raise
def check_rate_limit(self, endpoint_url):
try:
return self.api.CheckRateLimit(endpoint_url)
except error.TwitterError as e:
logging.critical(
'An error happened when rate limit of endpoint {} was checked: {}'
.format(endpoint_url, e.message))
return None
def verify_credentials(self):
try:
return self.api.VerifyCredentials(None, True)
except error.TwitterError as e:
logging.error(
'An error happened while checking the Twitter API credentials validity: {}'
.format(e.message))
raise
def get_followers_set(self):
try:
return set(self.api.GetFollowerIDs())
except error.TwitterError as e:
logging.critical(
'Twitter Supervisor is unable to get the user\'s followers IDs list: {}'
.format(e.message))
raise
def get_user(self, user_id):
try:
return self.api.GetUser(user_id), None
except error.TwitterError as e:
logging.error(
'An error happened while searching for user n°{0}: {1}'.format(
user_id, e.message))
return None, e.message
def get_friendship_lookup(self, users_id):
try:
return self.api.LookupFriendship(users_id)
except error.TwitterError as e:
logging.critical(
'An error happened while looking up friendships: {}'.format(
e.message))
raise
def get_friendship_show(self, target_id):
try:
return self.tweepy_api.show_friendship(
source_screen_name=self.username, target_id=target_id), None
except tweepy.TweepError as e:
return None, e
def send_direct_message(self, text):
logging.info('Sending direct message: \"{}\"'.format(text))
try:
return self.api.PostDirectMessage(text, screen_name=self.username)
except error.TwitterError as e:
logging.error('Unable to send direct message: {}'.format(
e.message))
return None
def get_user_timeline(self):
try:
return self.api.GetUserTimeline(screen_name=self.username,
count=200,
since_id=20)
except error.TwitterError as e:
logging.error('Unable to get user @{0} timeline: {1}'.format(
self.username, e.message))
return None
def get_favorites(self):
try:
return self.api.GetFavorites(screen_name=self.username,
count=200,
since_id=20)
except error.TwitterError as e:
logging.error('Unable to get user @{0} favorites: {1}'.format(
self.username, e.message))
return None
def delete_status(self, status_id):
try:
return self.api.DestroyStatus(status_id)
except error.TwitterError as e:
logging.error(
'Unable to delete status n°{0} because of error: {1}'.format(
status_id, e.message))
return None
def delete_favorite(self, status_id):
try:
return self.api.DestroyFavorite(status_id=status_id)
except error.TwitterError as e:
logging.error(
'Unable to delete favorite tweet n°{0} because of error: {1}'.
format(status_id, e.message))
return None
def delete_old_stuff(self, items_type, number_of_preserved_items):
if items_type == 'tweet' or items_type == 'retweet':
items = self.get_user_timeline()
rate_limit = self.check_rate_limit(self.DESTROY_STATUS_ENDPOINT)
if items_type == 'retweet':
items = list(filter(lambda x: x.retweeted is True, items))
elif items_type == 'favorite':
items = self.get_favorites()
rate_limit = self.check_rate_limit(self.DESTROY_FAVORITE_ENDPOINT)
else:
logging.error(
'This type of item to delete is not valid: {0}'.format(
items_type))
return []
if rate_limit is not None:
logging.debug(
'Deletable status - Remaining: {} - Reset: {}'.format(
rate_limit.remaining, rate_limit.reset))
if rate_limit.remaining < len(items) - number_of_preserved_items:
start_index = len(items) - rate_limit.remaining
else:
start_index = number_of_preserved_items
else:
logging.error(
'Unable to check the rate limit of the endpoint used to destroy {0}. No {0} will be deleted.'
)
return []
deleted_items = []
for i in range(start_index, len(items)):
if items_type == 'favorite':
deleted_item = self.delete_favorite(items[i].id)
else:
deleted_item = self.delete_status(items[i].id)
if deleted_item is not None:
deleted_items.append(deleted_item)
logging.info('Delete {0} n°{1} from {2}'.format(
items_type, items[i].id, items[i].user.screen_name))
return deleted_items
class Moody:
"""
Enables moody_py Twitter functionality by using python-twitter wrapper for Twitter API.
"""
def __init__(self):
"""
Initializes python-twitter wrapper with the Twitter API credentials
"""
self.api = Api(consumer_key=os.environ["consumer_key"],
consumer_secret=os.environ["consumer_secret"],
access_token_key=os.environ["access_token_key"],
access_token_secret=os.environ["access_token_secret"])
self.redis_search_engine = Redis()
logging.info('App name: ' +
self.redis_search_engine.get_string('app:name'))
def verify_credentials(self):
"""
Verifies if the given tokens are valid
:return: A boolean value stating if the credentials are valid
"""
try:
user = self.api.VerifyCredentials()
logging.info('Successfully verified ' + user.screen_name)
return True
except TwitterError as e:
logging.error('Error verifying credentials: %s',
e.message[0]['message'])
return False
def validate_request(self, twitter_request, authorization_header):
"""
Validates a request by matching the authorization header
:param twitter_request: Request received on routing endpoints
:param authorization_header: Header containing the authorization details
:return: Boolean True if validation is successful False otherwise
"""
received_passkey = authorization_header.split(" ")[1]
user_passkey = self.redis_search_engine.get_string(
'user:'******'Error validating request for user %s',
twitter_request.requested_by)
return False
def tweet(self, twitter_request):
"""
Posts a tweet to a Twitter account.
:param twitter_request: TwitterRequest containing necessary tweet information
:return: TwitterResponse stating if the tweet has been posted
"""
twitter_content = twitter_request.content
if twitter_content is None or len(twitter_content) == 0:
return TwitterResponse(
description='Twitter content to post cannot be empty!')
try:
status = self.api.PostUpdate(twitter_content)
logging.info('Posted twit with status: %s', status)
return TwitterResponse(status)
except TwitterError as e:
logging.error('Error posting twit: %s', e.message[0]['message'])
return TwitterResponse(
description='Fatal error while posting tweet. ' +
e.message[0]['message'])
def mood(self, twitter_request):
"""
Resolves a genre based on the YahooWeather condition code
:param twitter_request: TwitterRequest containing necessary YahooWeather condition code
:return: a genre for a given YahooWeather condition code
"""
genre_list = self.redis_search_engine.get_genre_list(
twitter_request.content)
genre = utils.get_random_from_collection(genre_list)
logging.info('Resolved genre %s for YahooWeather condition code %s',
genre, twitter_request.content)
return genre
def get_own(api: Api) -> User:
if get_own._cache:
return get_own._cache
data: User = api.VerifyCredentials(skip_status=True)
get_own._cache = data
return data
