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