class TweepyAPITests(unittest.TestCase): def setUp(self): auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret) auth.set_access_token(oauth_token, oauth_token_secret) self.api = API(auth) self.api.retry_count = 2 self.api.retry_delay = 5 def testhometimeline(self): self.api.home_timeline() def testfriendstimeline(self): self.api.friends_timeline() def testusertimeline(self): self.api.user_timeline() self.api.user_timeline('twitter') def testmentions(self): self.api.mentions() def testretweetedbyme(self): self.api.retweeted_by_me() def testretweetedbyuser(self): self.api.retweeted_by_user('twitter') def testretweetedtome(self): self.api.retweeted_to_me() def testretweetsofme(self): self.api.retweets_of_me() def testretweet(self): s = self.api.retweet(test_tweet_id) s.destroy() def testretweets(self): self.api.retweets(test_tweet_id) def testgetstatus(self): self.api.get_status(id=test_tweet_id) def testupdateanddestroystatus(self): # test update text = 'testing %i' % random.randint(0, 1000) update = self.api.update_status(status=text) self.assertEqual(update.text, text) # test destroy deleted = self.api.destroy_status(id=update.id) self.assertEqual(deleted.id, update.id) def testgetuser(self): u = self.api.get_user('twitter') self.assertEqual(u.screen_name, 'twitter') u = self.api.get_user(783214) self.assertEqual(u.screen_name, 'twitter') def testsearchusers(self): self.api.search_users('twitter') def testme(self): me = self.api.me() self.assertEqual(me.screen_name, username) def testfriends(self): self.api.friends() def testfollowers(self): self.api.followers() def testdirectmessages(self): self.api.direct_messages() def testsentdirectmessages(self): self.api.sent_direct_messages() def testsendanddestroydirectmessage(self): # send sent_dm = self.api.send_direct_message(username, text='test message') self.assertEqual(sent_dm.text, 'test message') self.assertEqual(sent_dm.sender.screen_name, username) self.assertEqual(sent_dm.recipient.screen_name, username) # destroy destroyed_dm = self.api.destroy_direct_message(sent_dm.id) self.assertEqual(destroyed_dm.text, sent_dm.text) self.assertEqual(destroyed_dm.id, sent_dm.id) self.assertEqual(destroyed_dm.sender.screen_name, username) self.assertEqual(destroyed_dm.recipient.screen_name, username) def testcreatedestroyfriendship(self): enemy = self.api.destroy_friendship('twitter') self.assertEqual(enemy.screen_name, 'twitter') # Wait 5 seconds to allow Twitter time # to process the friendship destroy request. sleep(5) friend = self.api.create_friendship('twitter') self.assertEqual(friend.screen_name, 'twitter') def testshowfriendship(self): source, target = self.api.show_friendship(target_screen_name='twtiter') self.assert_(isinstance(source, Friendship)) self.assert_(isinstance(target, Friendship)) def testfriendsids(self): self.api.friends_ids(username) def testfollowersids(self): self.api.followers_ids(username) def testverifycredentials(self): self.assertNotEqual(self.api.verify_credentials(), False) # make sure that `me.status.entities` is not an empty dict me = self.api.verify_credentials(include_entities=True) self.assertTrue(me.status.entities) # `status` shouldn't be included me = self.api.verify_credentials(skip_status=True) self.assertFalse(hasattr(me, 'status')) def testratelimitstatus(self): self.api.rate_limit_status() """ TODO(josh): Remove once this deprecated API is gone. def testsetdeliverydevice(self): self.api.set_delivery_device('im') self.api.set_delivery_device('none') """ def testupdateprofilecolors(self): original = self.api.me() updated = self.api.update_profile_colors('000', '000', '000', '000', '000') # restore colors self.api.update_profile_colors( original.profile_background_color, original.profile_text_color, original.profile_link_color, original.profile_sidebar_fill_color, original.profile_sidebar_border_color ) self.assertEqual(updated.profile_background_color, '000') self.assertEqual(updated.profile_text_color, '000') self.assertEqual(updated.profile_link_color, '000') self.assertEqual(updated.profile_sidebar_fill_color, '000') self.assertEqual(updated.profile_sidebar_border_color, '000') """ def testupateprofileimage(self): self.api.update_profile_image('examples/profile.png') def testupdateprofilebg(self): self.api.update_profile_background_image('examples/bg.png') """ def testupdateprofile(self): original = self.api.me() profile = { 'name': 'Tweepy test 123', 'url': 'http://www.example.com', 'location': 'pytopia', 'description': 'just testing things out' } updated = self.api.update_profile(**profile) self.api.update_profile( name = original.name, url = original.url, location = original.location, description = original.description ) for k,v in profile.items(): if k == 'email': continue self.assertEqual(getattr(updated, k), v) def testfavorites(self): self.api.favorites() def testcreatedestroyfavorite(self): self.api.create_favorite(4901062372) self.api.destroy_favorite(4901062372) def testenabledisablenotifications(self): self.api.enable_notifications('twitter') self.api.disable_notifications('twitter') def testcreatedestroyblock(self): self.api.create_block('twitter') self.assertEqual(self.api.exists_block('twitter'), True) self.api.destroy_block('twitter') self.assertEqual(self.api.exists_block('twitter'), False) self.api.create_friendship('twitter') # restore def testblocks(self): self.api.blocks() def testblocksids(self): self.api.blocks_ids() def testcreateupdatedestroylist(self): self.api.create_list('tweeps') # XXX: right now twitter throws a 500 here, issue is being looked into by twitter. #self.api.update_list('tweeps', mode='private') self.api.destroy_list('tweeps') def testlists(self): self.api.lists() def testlistsmemberships(self): self.api.lists_memberships() def testlistssubscriptions(self): self.api.lists_subscriptions() def testlisttimeline(self): self.api.list_timeline('applepie', 'stars') def testgetlist(self): self.api.get_list('applepie', 'stars') def testaddremovelistmember(self): uid = self.api.get_user('twitter').id self.api.add_list_member('test', uid) self.api.remove_list_member('test', uid) def testlistmembers(self): self.api.list_members('applepie', 'stars') def testislistmember(self): uid = self.api.get_user('applepie').id self.api.is_list_member('applepie', 'stars', uid) def testsubscribeunsubscribelist(self): self.api.subscribe_list('applepie', 'stars') self.api.unsubscribe_list('applepie', 'stars') def testlistsubscribers(self): self.api.list_subscribers('applepie', 'stars') def testissubscribedlist(self): uid = self.api.get_user('applepie').id self.api.is_subscribed_list('applepie', 'stars', uid) def testsavedsearches(self): s = self.api.create_saved_search('test') self.api.saved_searches() self.assertEqual(self.api.get_saved_search(s.id).query, 'test') self.api.destroy_saved_search(s.id) def testsearch(self): self.api.search('tweepy') def testtrends(self): self.api.trends_daily() self.api.trends_weekly() def testgeoapis(self): def place_name_in_list(place_name, place_list): """Return True if a given place_name is in place_list.""" return any([x.full_name.lower() == place_name.lower() for x in place_list]) twitter_hq = self.api.geo_similar_places(lat=37, long= -122, name='Twitter HQ') # Assumes that twitter_hq is first Place returned... self.assertEqual(twitter_hq[0].id, '3bdf30ed8b201f31') # Test various API functions using Austin, TX, USA self.assertEqual(self.api.geo_id(id='c3f37afa9efcf94b').full_name, 'Austin, TX') self.assertTrue(place_name_in_list('Austin, TX', self.api.nearby_places(lat=30.267370168467806, long= -97.74261474609375))) # Austin, TX, USA self.assertTrue(place_name_in_list('Austin, TX', self.api.reverse_geocode(lat=30.267370168467806, long= -97.74261474609375))) # Austin, TX, USA
class TweepyApi(BaseTweepyApi, ApiAdapter): """ A `ApiAdapter` implementation using `tweepy` library. http://github.com/tweepy/tweepy/ """ def __init__(self, *args, **kwargs): ApiAdapter.__init__(self, *args, **kwargs) # from `turses.api.base.ApiAdapter` def init_api(self): oauth_handler = TweepyOAuthHandler(self._consumer_key, self._consumer_secret) oauth_handler.set_access_token(self._access_token_key, self._access_token_secret) self._api = BaseTweepyApi(oauth_handler) @to_user def verify_credentials(self): return self._api.me() @to_user @include_entities def get_user(self, screen_name, **kwargs): return self._api.get_user(screen_name=screen_name, **kwargs) # timelines @to_status @include_entities def get_home_timeline(self, **kwargs): tweets = self._api.home_timeline(**kwargs) retweets = self._api.retweeted_to_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_user_timeline(self, screen_name, **kwargs): return self._api.user_timeline(screen_name, **kwargs) @to_status @include_entities def get_own_timeline(self, **kwargs): me = self.verify_credentials() tweets = self._api.user_timeline(screen_name=me.screen_name, **kwargs) retweets = self._api.retweeted_by_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_mentions(self, **kwargs): return self._api.mentions(**kwargs) @to_status @include_entities def get_favorites(self, **kwargs): return self._api.favorites(**kwargs) @to_direct_message @include_entities def get_direct_messages(self, **kwargs): dms = self._api.direct_messages(**kwargs) sent = self._api.sent_direct_messages(**kwargs) dms.extend(sent) return dms # NOTE: # `get_thread` is not decorated with `to_status` because # it uses `TweepyApi.get_user_timeline` which is already # decorated @include_entities def get_thread(self, status, **kwargs): """ Get the conversation to which `status` belongs. It filters the last tweets by the participanting users and based on mentions to each other. """ author = status.authors_username mentioned = status.mentioned_usernames if author not in mentioned: mentioned.append(author) tweets = [] for username in mentioned: tweets.extend(self.get_user_timeline(username, **kwargs)) def belongs_to_conversation(status): for username in mentioned: if username in status.text: return True return filter(belongs_to_conversation, tweets) @to_status_from_search @include_entities def search(self, text, **kwargs): return self._api.search(text, **kwargs) def update(self, text): self._api.update_status(text) def destroy_status(self, status): self._api.destroy_status(status.id) def retweet(self, status): self._api.retweet(status.id) def direct_message(self, username, text): self._api.send_direct_message(user=username, text=text) def destroy_direct_message(self, dm): self._api.destroy_direct_message(dm.id) def create_friendship(self, screen_name): self._api.create_friendship(screen_name=screen_name) def destroy_friendship(self, screen_name): self._api.destroy_friendship(screen_name=screen_name) def create_favorite(self, status): self._api.create_favorite(status.id) def destroy_favorite(self, status): self._api.destroy_favorite(status.id) # list methods def get_lists(self, screen_name): raise NotImplementedError def get_own_lists(self): raise NotImplementedError def get_list_memberships(self): raise NotImplementedError def get_list_subscriptions(self): raise NotImplementedError def get_list_timeline(self, list): raise NotImplementedError def get_list_members(self, list): raise NotImplementedError def is_list_member(self, user, list): raise NotImplementedError def subscribe_to_list(self, list): raise NotImplementedError def get_list_subscribers(self, list): raise NotImplementedError def is_list_subscriber(self, user, list): raise NotImplementedError
def run(api: tweepy.API, user: tweepy.User): with open(KEYS_FILE, "r") as f: keys = yaml.load(f, Loader=yaml.FullLoader) curr_tweets = 0 while curr_tweets < MAX_TWEETS: kwargs = { "user_id": user.id_str, "screen_name": user.screen_name, "exclude_replies": False, "include_rts": False, "count": TWEETS_PER_CALL } data = list(api.user_timeline(**kwargs)) for d in data: if (d.in_reply_to_screen_name is None) or (d.in_reply_to_screen_name == keys["account"]): if not d.favorited: api.create_favorite(d.id) logging.info(f"Liked tweet with ID: {d.id_str}") if not d.retweeted: api.retweet(d.id) logging.info(f"Retweeted tweet with ID: {d.id_str}") curr_tweets += TWEETS_PER_CALL
def post_reply_tweet(api: API, tweet: str, status_id_to_reply_to: int) -> None: api.create_favorite( status_id_to_reply_to ) # To prevent from replying twice. Also just kinda funny user_to_reply_to = api.get_status(status_id_to_reply_to).author.screen_name api.update_status(f'@{user_to_reply_to} {tweet}', status_id_to_reply_to, auto_populate_reply_metadata=True)
def relike(api: tweepy.API, start_pointer: int) -> None: from datetime import datetime from time import sleep liked_list = list(map(lambda item: int(item.strip()), open(ENV_PATH + FAVKILL_LATEST, 'r').readlines())) index = start_pointer while index < len(liked_list): id_ = liked_list[index] try: logger.info('Try: #{:04d}, {:d}'.format(index, id_)) sleep(3) result = api.create_favorite(liked_list[index]) logger.info('OK. Liked: {:d}'.format(result.id)) logger.info(' ' + html.unescape(result.text.replace('\n', '').strip())[:30]) index += 1 except tweepy.error.TweepError as te: reason = te.reason if 'You have already' in reason or \ 'No status found' in reason or \ 'protected users' in reason: if 'You have already' in reason: logger.warning('Already liked.') elif 'No status found' in reason: logger.warning('Not found.') else: logger.warning('Protected tweet.') index += 1 elif 'might be automated' in reason or '429' in reason: if 'might be automated' in reason: logger.error('Tool filter detected.') else: logger.error('Rate limit exceeded.') waittime = int(600 - datetime.now().timestamp() % 600) logger.info('Waiting until the next x0 minutes.' + '({} sec.)'.format(waittime)) sleep(waittime) continue else: logger.error('Uncaught error: {}'.format(reason)) break
class TweepyApi(BaseTweepyApi, ApiAdapter): """ A :class:`turses.api.ApiAdapter` implementation using `tweepy` library. http://github.com/tweepy/tweepy/ """ def __init__(self, *args, **kwargs): ApiAdapter.__init__(self, *args, **kwargs) # from `turses.api.base.ApiAdapter` def init_api(self): oauth_handler = TweepyOAuthHandler(self._consumer_key, self._consumer_secret) oauth_handler.set_access_token(self._access_token_key, self._access_token_secret) self._api = BaseTweepyApi(oauth_handler) @to_user def verify_credentials(self): return self._api.me() @to_user @include_entities def get_user(self, screen_name, **kwargs): return self._api.get_user(screen_name=screen_name, **kwargs) # timelines @to_status @include_entities def get_status(self, status_id, **kwargs): return self._api.get_status(status_id, **kwargs) @to_status @include_entities def get_home_timeline(self, **kwargs): tweets = self._api.home_timeline(**kwargs) retweets = self._api.retweeted_to_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_user_timeline(self, screen_name, **kwargs): return self._api.user_timeline(screen_name, **kwargs) @to_status @include_entities def get_own_timeline(self, **kwargs): me = self.verify_credentials() tweets = self._api.user_timeline(screen_name=me.screen_name, **kwargs) retweets = self._api.retweeted_by_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_mentions(self, **kwargs): return self._api.mentions(**kwargs) @to_status @include_entities def get_favorites(self, **kwargs): return self._api.favorites(**kwargs) @to_direct_message @include_entities def get_direct_messages(self, **kwargs): dms = self._api.direct_messages(**kwargs) sent = self._api.sent_direct_messages(**kwargs) dms.extend(sent) return dms @include_entities def get_thread(self, status, **kwargs): """ Get the conversation to which `status` belongs. """ users_in_conversation = [status.authors_username] # Save the users that are mentioned for user in status.mentioned_usernames: if user not in users_in_conversation: users_in_conversation.append(user) # Fetch the tweets from participants before and after `status` # was published tweets_from_participants = [] for user in users_in_conversation: user_tweets = self._get_older_and_newer_tweets(user, status.id) tweets_from_participants.extend(user_tweets) def belongs_to_conversation(tweet): for user in users_in_conversation: if user in tweet.text: return True return filter(belongs_to_conversation, tweets_from_participants) def _get_older_and_newer_tweets(self, screen_name, tweet_id, count=20): """ Get tweets from the user with `screen_name` username that are older and newer than `tweet_id`. By default, 20 tweets are fetched. If provided, `count` controls how many tweets are requested. """ older = self.get_user_timeline(screen_name, max_id=tweet_id, count=count / 2) newer = self.get_user_timeline(screen_name, since_id=tweet_id, count=count / 2) return older + newer def get_message_thread(self, dm, **kwargs): messages = self.get_direct_messages(**kwargs) me = self.verify_credentials() if dm.sender_screen_name == me.screen_name: with_user = dm.recipient_screen_name else: with_user = dm.sender_screen_name def belongs_to_conversation(message): return (message.sender_screen_name == with_user or message.recipient_screen_name == with_user) return filter(belongs_to_conversation, messages) @to_status_from_search @include_entities def search(self, text, **kwargs): return self._api.search(text, **kwargs) @to_status @include_entities def get_retweets_of_me(self, **kwargs): return self._api.retweets_of_me(**kwargs) def update(self, text): self._api.update_status(text) def destroy_status(self, status): self._api.destroy_status(status.id) def retweet(self, status): self._api.retweet(status.id) def direct_message(self, username, text): self._api.send_direct_message(user=username, text=text) def destroy_direct_message(self, dm): self._api.destroy_direct_message(dm.id) def create_friendship(self, screen_name): self._api.create_friendship(screen_name=screen_name) def destroy_friendship(self, screen_name): self._api.destroy_friendship(screen_name=screen_name) def create_favorite(self, status): self._api.create_favorite(status.id) def destroy_favorite(self, status): self._api.destroy_favorite(status.id) # list methods @to_list def get_lists(self, screen_name): return self._api.lists(screen_name) @to_list def get_own_lists(self): return self._api.lists() @to_list def get_list_memberships(self): return self._api.lists_memberships() @to_list def get_list_subscriptions(self): return self._api.lists_subscriptions() @to_status def get_list_timeline(self, a_list): owner = a_list.owner.screen_name return self._api.list_timeline(owner=owner, slug=a_list.slug) @to_user def get_list_members(self, a_list): owner = a_list.owner.screen_name return self._api.list_members(owner=owner, slug=a_list.slug) def is_list_member(self, user, a_list): return bool( self._api.is_list_member( owner=user.screen_name, slug=a_list.slug, user_id=user.id, )) @to_list def subscribe_to_list(self, a_list): owner = a_list.owner return self._api.subscribe_list(owner=owner.screen_name, slug=a_list.slug) @to_user def get_list_subscribers(self, a_list): owner = a_list.owner return self._api.list_subscribers( owner=owner.screen_name, slug=a_list.slug, ) def is_list_subscriber(self, user, a_list): return bool( self._api.is_subscribed_list( owner=user.screen_name, slug=a_list.slug, user_id=user.id, ))
class TweepyApi(BaseTweepyApi, ApiAdapter): """ A :class:`turses.api.ApiAdapter` implementation using `tweepy` library. http://github.com/tweepy/tweepy/ """ def __init__(self, *args, **kwargs): ApiAdapter.__init__(self, *args, **kwargs) # from `turses.api.base.ApiAdapter` def init_api(self): oauth_handler = TweepyOAuthHandler(self._consumer_key, self._consumer_secret, secure=configuration.twitter['use_https']) oauth_handler.set_access_token(self._access_token_key, self._access_token_secret) self._api = BaseTweepyApi(oauth_handler, secure=configuration.twitter['use_https']) @to_user def verify_credentials(self): return self._api.me() @to_user @include_entities def get_user(self, screen_name, **kwargs): return self._api.get_user(screen_name=screen_name, **kwargs) # timelines @to_status @include_entities def get_status(self, status_id, **kwargs): return self._api.get_status(status_id, **kwargs) @to_status @include_entities def get_home_timeline(self, **kwargs): tweets = self._api.home_timeline(**kwargs) retweets = self._api.retweeted_to_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_user_timeline(self, screen_name, **kwargs): return self._api.user_timeline(screen_name, **kwargs) @to_status @include_entities def get_own_timeline(self, **kwargs): me = self.verify_credentials() tweets = self._api.user_timeline(screen_name=me.screen_name, **kwargs) retweets = self._api.retweeted_by_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_mentions(self, **kwargs): return self._api.mentions(**kwargs) @to_status @include_entities def get_favorites(self, **kwargs): return self._api.favorites(**kwargs) @to_direct_message @include_entities def get_direct_messages(self, **kwargs): dms = self._api.direct_messages(**kwargs) sent = self._api.sent_direct_messages(**kwargs) dms.extend(sent) return dms @include_entities def get_thread(self, status, **kwargs): """ Get the conversation to which `status` belongs. """ users_in_conversation = [status.authors_username] # Save the users that are mentioned for user in status.mentioned_usernames: if user not in users_in_conversation: users_in_conversation.append(user) # Fetch the tweets from participants before and after `status` # was published tweets_from_participants = [] for user in users_in_conversation: user_tweets = self._get_older_and_newer_tweets(user, status.id) tweets_from_participants.extend(user_tweets) def belongs_to_conversation(tweet): for user in users_in_conversation: if user in tweet.text: return True return filter(belongs_to_conversation, tweets_from_participants) def _get_older_and_newer_tweets(self, screen_name, tweet_id, count=20): """ Get tweets from the user with `screen_name` username that are older and newer than `tweet_id`. By default, 20 tweets are fetched. If provided, `count` controls how many tweets are requested. """ older = self.get_user_timeline(screen_name, max_id=tweet_id, count=count/2) newer = self.get_user_timeline(screen_name, since_id=tweet_id, count=count/2) return older + newer def get_message_thread(self, dm, **kwargs): messages = self.get_direct_messages(**kwargs) me = self.verify_credentials() if dm.sender_screen_name == me.screen_name: with_user = dm.recipient_screen_name else: with_user = dm.sender_screen_name def belongs_to_conversation(message): return (message.sender_screen_name == with_user or message.recipient_screen_name == with_user) return filter(belongs_to_conversation, messages) @to_status_from_search @include_entities def search(self, text, **kwargs): return self._api.search(text, **kwargs) @to_status @include_entities def get_retweets_of_me(self, **kwargs): return self._api.retweets_of_me(**kwargs) def update(self, text): self._api.update_status(text) def reply(self, status, text): self._api.update_status(text, in_reply_to_status_id=status.id) def destroy_status(self, status): self._api.destroy_status(status.id) def retweet(self, status): self._api.retweet(status.id) def direct_message(self, username, text): self._api.send_direct_message(user=username, text=text) def destroy_direct_message(self, dm): self._api.destroy_direct_message(dm.id) def create_friendship(self, screen_name): self._api.create_friendship(screen_name=screen_name) def destroy_friendship(self, screen_name): self._api.destroy_friendship(screen_name=screen_name) def create_favorite(self, status): self._api.create_favorite(status.id) def destroy_favorite(self, status): self._api.destroy_favorite(status.id) # list methods @to_list def get_lists(self, screen_name): return self._api.lists(screen_name) @to_list def get_own_lists(self): return self._api.lists() @to_list def get_list_memberships(self): return self._api.lists_memberships() @to_list def get_list_subscriptions(self): return self._api.lists_subscriptions() @to_status def get_list_timeline(self, a_list): owner = a_list.owner.screen_name return self._api.list_timeline(owner=owner, slug=a_list.slug) @to_user def get_list_members(self, a_list): owner = a_list.owner.screen_name return self._api.list_members(owner=owner, slug=a_list.slug) def is_list_member(self, user, a_list): return bool(self._api.is_list_member(owner=user.screen_name, slug=a_list.slug, user_id=user.id,)) @to_list def subscribe_to_list(self, a_list): owner = a_list.owner return self._api.subscribe_list(owner=owner.screen_name, slug=a_list.slug) @to_user def get_list_subscribers(self, a_list): owner = a_list.owner return self._api.list_subscribers(owner=owner.screen_name, slug=a_list.slug,) def is_list_subscriber(self, user, a_list): return bool(self._api.is_subscribed_list(owner=user.screen_name, slug=a_list.slug, user_id=user.id,))
class TweepyAPITests(unittest.TestCase): def setUp(self): auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret) auth.set_access_token(oauth_token, oauth_token_secret) self.api = API(auth) self.api.retry_count = 2 self.api.retry_delay = 5 def testhometimeline(self): self.api.home_timeline() def testfriendstimeline(self): self.api.friends_timeline() def testusertimeline(self): self.api.user_timeline() self.api.user_timeline('twitter') def testmentions(self): self.api.mentions() def testretweetedbyme(self): self.api.retweeted_by_me() def testretweetedbyuser(self): self.api.retweeted_by_user('twitter') def testretweetedtome(self): self.api.retweeted_to_me() def testretweetsofme(self): self.api.retweets_of_me() def testretweet(self): s = self.api.retweet(123) s.destroy() def testretweets(self): self.api.retweets(123) def testgetstatus(self): self.api.get_status(id=123) def testupdateanddestroystatus(self): # test update text = 'testing %i' % random.randint(0, 1000) update = self.api.update_status(status=text) self.assertEqual(update.text, text) # test destroy deleted = self.api.destroy_status(id=update.id) self.assertEqual(deleted.id, update.id) def testgetuser(self): u = self.api.get_user('twitter') self.assertEqual(u.screen_name, 'twitter') u = self.api.get_user(783214) self.assertEqual(u.screen_name, 'twitter') def testsearchusers(self): self.api.search_users('twitter') def testme(self): me = self.api.me() self.assertEqual(me.screen_name, username) def testfriends(self): self.api.friends() def testfollowers(self): self.api.followers() def testdirectmessages(self): self.api.direct_messages() def testsentdirectmessages(self): self.api.sent_direct_messages() def testsendanddestroydirectmessage(self): # send sent_dm = self.api.send_direct_message(username, text='test message') self.assertEqual(sent_dm.text, 'test message') self.assertEqual(sent_dm.sender.screen_name, username) self.assertEqual(sent_dm.recipient.screen_name, username) # destroy destroyed_dm = self.api.destroy_direct_message(sent_dm.id) self.assertEqual(destroyed_dm.text, sent_dm.text) self.assertEqual(destroyed_dm.id, sent_dm.id) self.assertEqual(destroyed_dm.sender.screen_name, username) self.assertEqual(destroyed_dm.recipient.screen_name, username) def testcreatedestroyfriendship(self): enemy = self.api.destroy_friendship('twitter') self.assertEqual(enemy.screen_name, 'twitter') self.assertFalse(self.api.exists_friendship(username, 'twitter')) friend = self.api.create_friendship('twitter') self.assertEqual(friend.screen_name, 'twitter') self.assertTrue(self.api.exists_friendship(username, 'twitter')) def testshowfriendship(self): source, target = self.api.show_friendship(target_screen_name='twtiter') self.assert_(isinstance(source, Friendship)) self.assert_(isinstance(target, Friendship)) def testfriendsids(self): self.api.friends_ids(username) def testfollowersids(self): self.api.followers_ids(username) def testverifycredentials(self): self.assertNotEqual(self.api.verify_credentials(), False) # make sure that `me.status.entities` is not an empty dict me = self.api.verify_credentials(include_entities=True) self.assertTrue(me.status.entities) # `status` shouldn't be included me = self.api.verify_credentials(skip_status=True) self.assertFalse(hasattr(me, 'status')) api = API(BasicAuthHandler('bad', 'password')) self.assertEqual(api.verify_credentials(), False) def testratelimitstatus(self): self.api.rate_limit_status() def testsetdeliverydevice(self): self.api.set_delivery_device('im') self.api.set_delivery_device('none') def testupdateprofilecolors(self): original = self.api.me() updated = self.api.update_profile_colors('000', '000', '000', '000', '000') # restore colors self.api.update_profile_colors(original.profile_background_color, original.profile_text_color, original.profile_link_color, original.profile_sidebar_fill_color, original.profile_sidebar_border_color) self.assertEqual(updated.profile_background_color, '000') self.assertEqual(updated.profile_text_color, '000') self.assertEqual(updated.profile_link_color, '000') self.assertEqual(updated.profile_sidebar_fill_color, '000') self.assertEqual(updated.profile_sidebar_border_color, '000') """ def testupateprofileimage(self): self.api.update_profile_image('examples/profile.png') def testupdateprofilebg(self): self.api.update_profile_background_image('examples/bg.png') """ def testupdateprofile(self): original = self.api.me() profile = { 'name': 'Tweepy test 123', 'url': 'http://www.example.com', 'location': 'pytopia', 'description': 'just testing things out' } updated = self.api.update_profile(**profile) self.api.update_profile(name=original.name, url=original.url, location=original.location, description=original.description) for k, v in profile.items(): if k == 'email': continue self.assertEqual(getattr(updated, k), v) def testfavorites(self): self.api.favorites() def testcreatedestroyfavorite(self): self.api.create_favorite(4901062372) self.api.destroy_favorite(4901062372) def testenabledisablenotifications(self): self.api.enable_notifications('twitter') self.api.disable_notifications('twitter') def testcreatedestroyblock(self): self.api.create_block('twitter') self.assertEqual(self.api.exists_block('twitter'), True) self.api.destroy_block('twitter') self.assertEqual(self.api.exists_block('twitter'), False) self.api.create_friendship('twitter') # restore def testblocks(self): self.api.blocks() def testblocksids(self): self.api.blocks_ids() def testcreateupdatedestroylist(self): self.api.create_list('tweeps') # XXX: right now twitter throws a 500 here, issue is being looked into by twitter. #self.api.update_list('tweeps', mode='private') self.api.destroy_list('tweeps') def testlists(self): self.api.lists() def testlistsmemberships(self): self.api.lists_memberships() def testlistssubscriptions(self): self.api.lists_subscriptions() def testlisttimeline(self): self.api.list_timeline('applepie', 'stars') def testgetlist(self): self.api.get_list('applepie', 'stars') def testaddremovelistmember(self): uid = self.api.get_user('twitter').id self.api.add_list_member('test', uid) self.api.remove_list_member('test', uid) def testlistmembers(self): self.api.list_members('applepie', 'stars') def testislistmember(self): uid = self.api.get_user('applepie').id self.api.is_list_member('applepie', 'stars', uid) def testsubscribeunsubscribelist(self): self.api.subscribe_list('applepie', 'stars') self.api.unsubscribe_list('applepie', 'stars') def testlistsubscribers(self): self.api.list_subscribers('applepie', 'stars') def testissubscribedlist(self): uid = self.api.get_user('applepie').id self.api.is_subscribed_list('applepie', 'stars', uid) def testsavedsearches(self): s = self.api.create_saved_search('test') self.api.saved_searches() self.assertEqual(self.api.get_saved_search(s.id).query, 'test') self.api.destroy_saved_search(s.id) def testsearch(self): self.api.search('tweepy') def testtrends(self): self.api.trends() self.api.trends_current() self.api.trends_daily() self.api.trends_weekly() def testgeoapis(self): self.api.geo_id(id='c3f37afa9efcf94b') # Austin, TX, USA self.api.nearby_places(lat=30.267370168467806, long=-97.74261474609375) # Austin, TX, USA self.api.reverse_geocode(lat=30.267370168467806, long=-97.74261474609375) # Austin, TX, USA
class TweepyApi(BaseTweepyApi, Api): """ A `Api` implementation using `tweepy` library. http://github.com/tweepy/tweepy/ """ def __init__(self, *args, **kwargs): Api.__init__(self, *args, **kwargs) # conversion to `turses.models` def _to_status(self, statuses): def to_status(status): text = status.text is_reply = False in_reply_to_user = '' is_retweet = False retweet_count = 0 is_favorite = False author = '' if getattr(status, 'retweeted_status', False): is_retweet = True text = status.retweeted_status.text retweet_count = status.retweet_count author = status.retweeted_status.author.screen_name if status.in_reply_to_screen_name: is_reply = True in_reply_to_user = status.in_reply_to_screen_name if status.favorited: is_favorite = True kwargs = { 'id': status.id, 'created_at': status.created_at, 'user': status.user.screen_name, 'text': text, 'is_retweet': is_retweet, 'is_reply': is_reply, 'is_favorite': is_favorite, 'in_reply_to_user': in_reply_to_user, 'retweet_count': retweet_count, 'author': author, } return Status(**kwargs) if isinstance(statuses, list): return [to_status(status) for status in statuses] else: return to_status(statuses) def _to_direct_message(self, dms): def to_direct_message(dm): kwargs = { 'id': dm.id, 'created_at': dm.created_at, 'sender_screen_name': dm.sender_screen_name, 'recipient_screen_name': dm.recipient_screen_name, 'text': dm.text, } return DirectMessage(**kwargs) if isinstance(dms, list): return [to_direct_message(dm) for dm in dms] else: return to_direct_message(dms) def _to_list(self, lists): def to_list(l): created_at = datetime_from_twitter_datestring(l.created_at) if l.mode == u'private': private = True else: private = False kwargs = { 'id': l.id, 'owner': l.user.screen_name, 'created_at': created_at, 'name': l.name, 'description': l.description, 'member_count': l.member_count, 'subscriber_count': l.subscriber_count, 'private': private, } return List(**kwargs) if isinstance(lists, list): return [to_list(l) for l in lists] else: return to_list(lists) # from `turses.api.base.Api` def init_api(self): oauth_handler = TweepyOAuthHandler(self._consumer_key, self._consumer_secret) oauth_handler.set_access_token(self._access_token_key, self._access_token_secret) self._api = BaseTweepyApi(oauth_handler) def verify_credentials(self): def to_user(user): kwargs = { 'screen_name': user.screen_name, } return User(**kwargs) return to_user(self._api.me()) # timelines def get_home_timeline(self, **kwargs): tweets = self._api.home_timeline(**kwargs) retweets = self._api.retweeted_to_me(**kwargs) tweets.extend(retweets) return self._to_status(tweets) def get_user_timeline(self, screen_name, **kwargs): return self._to_status(self._api.user_timeline(screen_name, **kwargs)) def get_own_timeline(self, **kwargs): me = self.verify_credentials() tweets = self._api.user_timeline(screen_name=me.screen_name, **kwargs) retweets = self._api.retweeted_by_me(**kwargs) tweets.extend(retweets) return self._to_status(tweets) def get_mentions(self, **kwargs): return self._to_status(self._api.mentions(**kwargs)) def get_favorites(self, **kwargs): return self._to_status(self._api.favorites(**kwargs)) def get_direct_messages(self, **kwargs): dms = self._api.direct_messages(**kwargs) sent = self._api.sent_direct_messages(**kwargs) dms.extend(sent) return self._to_direct_message(dms) def get_thread(self, status, **kwargs): author = get_authors_username(status) mentioned = get_mentioned_usernames(status) if author not in mentioned: mentioned.append(author) tweets = [] for username in mentioned: tweets.extend(self.get_user_timeline(username, **kwargs)) def belongs_to_conversation(status): for username in mentioned: if username in status.text: return True return filter(belongs_to_conversation, tweets) def get_search(self, text, **kwargs): # `tweepy.API.search` returns `tweepy.models.SearchResult` objects instead # `tweepy.models.Status` so we have to convert them differently def to_status(status): kwargs = { 'id': status.id, 'created_at': status.created_at, 'user': status.from_user, 'text': status.text, } return Status(**kwargs) results = self._api.search(text, **kwargs) return [to_status(result) for result in results] def update(self, text): return self._api.update_status(text) def destroy_status(self, status): return self._to_status(self._api.destroy_status(status.id)) def retweet(self, status): return self._to_status(self._api.retweet(status.id)) def direct_message(self, username, text): return self._to_direct_message(self._api.send_direct_message(user=username, text=text)) def destroy_direct_message(self, dm): return self._to_direct_message(self._api.destroy_direct_message(dm.id)) # TODO: convert to `turses.models.User` def create_friendship(self, screen_name): self._api.create_friendship(screen_name=screen_name) def destroy_friendship(self, screen_name): self._api.destroy_friendship(screen_name=screen_name) def create_favorite(self, status): self._to_status(self._api.create_favorite(status.id)) def destroy_favorite(self, status): self._to_status(self._api.destroy_favorite(status.id)) # list methods def get_lists(self, screen_name): raise NotImplementedError def get_own_lists(self): raise NotImplementedError def get_list_memberships(self): raise NotImplementedError def get_list_subscriptions(self): raise NotImplementedError def get_list_timeline(self, list): raise NotImplementedError def get_list_members(self, list): raise NotImplementedError def is_list_member(self, user, list): raise NotImplementedError def subscribe_to_list(self, list): raise NotImplementedError def get_list_subscribers(self, list): raise NotImplementedError def is_list_subscriber(self, user, list): raise NotImplementedError
class TweepyAPITests(unittest.TestCase): def setUp(self): auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret) auth.set_access_token(oauth_token, oauth_token_secret) self.api = API(auth) self.api.retry_count = 2 self.api.retry_delay = 5 # TODO: Actually have some sort of better assertion def testgetoembed(self): data = self.api.get_oembed(test_tweet_id) self.assertEqual(data['author_name'], "Twitter") def testhometimeline(self): self.api.home_timeline() def testusertimeline(self): self.api.user_timeline() self.api.user_timeline('twitter') def testmentionstimeline(self): self.api.mentions_timeline() def testretweetsofme(self): self.api.retweets_of_me() def testretweet(self): # TODO(josh): Need a way to get random tweets to retweet. raise SkipTest() def testretweets(self): self.api.retweets(test_tweet_id) def testgetstatus(self): self.api.get_status(id=test_tweet_id) def testupdateanddestroystatus(self): # test update text = 'testing %i' % random.randint(0, 1000) update = self.api.update_status(status=text) self.assertEqual(update.text, text) # test destroy deleted = self.api.destroy_status(id=update.id) self.assertEqual(deleted.id, update.id) def testgetuser(self): u = self.api.get_user('twitter') self.assertEqual(u.screen_name, 'twitter') u = self.api.get_user(783214) self.assertEqual(u.screen_name, 'twitter') def testsearchusers(self): self.api.search_users('twitter') def testsuggestedcategories(self): self.api.suggested_categories() def testsuggestedusers(self): categories = self.api.suggested_categories() if len(categories) != 0: self.api.suggested_users(categories[0].slug) def testsuggesteduserstweets(self): categories = self.api.suggested_categories() if len(categories) != 0: self.api.suggested_users_tweets(categories[0].slug) def testme(self): me = self.api.me() self.assertEqual(me.screen_name, username) def testdirectmessages(self): self.api.direct_messages() def testsentdirectmessages(self): self.api.sent_direct_messages() def testsendanddestroydirectmessage(self): # send sent_dm = self.api.send_direct_message(username, text='test message') self.assertEqual(sent_dm.text, 'test message') self.assertEqual(sent_dm.sender.screen_name, username) self.assertEqual(sent_dm.recipient.screen_name, username) # destroy destroyed_dm = self.api.destroy_direct_message(sent_dm.id) self.assertEqual(destroyed_dm.text, sent_dm.text) self.assertEqual(destroyed_dm.id, sent_dm.id) self.assertEqual(destroyed_dm.sender.screen_name, username) self.assertEqual(destroyed_dm.recipient.screen_name, username) def testcreatedestroyfriendship(self): enemy = self.api.destroy_friendship('twitter') self.assertEqual(enemy.screen_name, 'twitter') # Wait 5 seconds to allow Twitter time # to process the friendship destroy request. sleep(5) friend = self.api.create_friendship('twitter') self.assertEqual(friend.screen_name, 'twitter') def testshowfriendship(self): source, target = self.api.show_friendship(target_screen_name='twtiter') self.assert_(isinstance(source, Friendship)) self.assert_(isinstance(target, Friendship)) def testfriendsids(self): self.api.friends_ids(username) def testfollowersids(self): self.api.followers_ids(username) def testfriends(self): self.api.friends(username) def testfollowers(self): self.api.followers(username) def testverifycredentials(self): self.assertNotEqual(self.api.verify_credentials(), False) # make sure that `me.status.entities` is not an empty dict me = self.api.verify_credentials(include_entities=True) self.assertTrue(me.status.entities) # `status` shouldn't be included me = self.api.verify_credentials(skip_status=True) self.assertFalse(hasattr(me, 'status')) def testratelimitstatus(self): self.api.rate_limit_status() """ TODO(josh): Remove once this deprecated API is gone. def testsetdeliverydevice(self): self.api.set_delivery_device('im') self.api.set_delivery_device('none') """ def testupdateprofilecolors(self): original = self.api.me() updated = self.api.update_profile_colors('000', '000', '000', '000', '000') # restore colors self.api.update_profile_colors(original.profile_background_color, original.profile_text_color, original.profile_link_color, original.profile_sidebar_fill_color, original.profile_sidebar_border_color) self.assertEqual(updated.profile_background_color, '000000') self.assertEqual(updated.profile_text_color, '000000') self.assertEqual(updated.profile_link_color, '000000') self.assertEqual(updated.profile_sidebar_fill_color, '000000') self.assertEqual(updated.profile_sidebar_border_color, '000000') """ def testupateprofileimage(self): self.api.update_profile_image('examples/profile.png') def testupdateprofilebg(self): self.api.update_profile_background_image('examples/bg.png') """ def testupdateprofile(self): original = self.api.me() profile = { 'name': 'Tweepy test 123', 'location': 'pytopia', 'description': 'just testing things out' } updated = self.api.update_profile(**profile) self.api.update_profile(name=original.name, url=original.url, location=original.location, description=original.description) for k, v in profile.items(): if k == 'email': continue self.assertEqual(getattr(updated, k), v) def testfavorites(self): self.api.favorites() def testcreatedestroyfavorite(self): self.api.create_favorite(4901062372) self.api.destroy_favorite(4901062372) def testcreatedestroyblock(self): self.api.create_block('twitter') self.api.destroy_block('twitter') self.api.create_friendship('twitter') # restore def testblocks(self): self.api.blocks() def testblocksids(self): self.api.blocks_ids() def testcreateupdatedestroylist(self): params = {'owner_screen_name': username, 'slug': 'tweeps'} l = self.api.create_list(name=params['slug'], **params) l = self.api.update_list(list_id=l.id, description='updated!') self.assertEqual(l.description, 'updated!') self.api.destroy_list(list_id=l.id) def testlistsall(self): self.api.lists_all() def testlistsmemberships(self): self.api.lists_memberships() def testlistssubscriptions(self): self.api.lists_subscriptions() def testlisttimeline(self): self.api.list_timeline('applepie', 'stars') def testgetlist(self): self.api.get_list(owner_screen_name='applepie', slug='stars') def testaddremovelistmember(self): params = { 'slug': 'test', 'owner_screen_name': username, 'screen_name': 'twitter' } def assert_list(l): self.assertEqual(l.name, params['slug']) assert_list(self.api.add_list_member(**params)) assert_list(self.api.remove_list_member(**params)) def testlistmembers(self): self.api.list_members('applepie', 'stars') def testshowlistmember(self): self.assertTrue( self.api.show_list_member(owner_screen_name='applepie', slug='stars', screen_name='NathanFillion')) def testsubscribeunsubscribelist(self): params = {'owner_screen_name': 'applepie', 'slug': 'stars'} self.api.subscribe_list(**params) self.api.unsubscribe_list(**params) def testlistsubscribers(self): self.api.list_subscribers('applepie', 'stars') def testshowlistsubscriber(self): self.assertTrue( self.api.show_list_subscriber('twitter', 'team', username)) def testsavedsearches(self): s = self.api.create_saved_search('test') self.api.saved_searches() self.assertEqual(self.api.get_saved_search(s.id).query, 'test') self.api.destroy_saved_search(s.id) def testsearch(self): self.api.search('tweepy') def testgeoapis(self): def place_name_in_list(place_name, place_list): """Return True if a given place_name is in place_list.""" return any([ x.full_name.lower() == place_name.lower() for x in place_list ]) twitter_hq = self.api.geo_similar_places(lat=37, long=-122, name='Twitter HQ') # Assumes that twitter_hq is first Place returned... self.assertEqual(twitter_hq[0].id, '3bdf30ed8b201f31') # Test various API functions using Austin, TX, USA self.assertEqual( self.api.geo_id(id='c3f37afa9efcf94b').full_name, 'Austin, TX') self.assertTrue( place_name_in_list( 'Austin, TX', self.api.reverse_geocode( lat=30.267370168467806, long=-97.74261474609375))) # Austin, TX, USA
class TweepyApi(BaseTweepyApi, ApiAdapter): """ A `ApiAdapter` implementation using `tweepy` library. http://github.com/tweepy/tweepy/ """ def __init__(self, *args, **kwargs): ApiAdapter.__init__(self, *args, **kwargs) # from `turses.api.base.ApiAdapter` def init_api(self): oauth_handler = TweepyOAuthHandler(self._consumer_key, self._consumer_secret) oauth_handler.set_access_token(self._access_token_key, self._access_token_secret) self._api = BaseTweepyApi(oauth_handler) @to_user def verify_credentials(self): return self._api.me() @to_user @include_entities def get_user(self, screen_name, **kwargs): return self._api.get_user(screen_name=screen_name, **kwargs) # timelines @to_status @include_entities def get_home_timeline(self, **kwargs): tweets = self._api.home_timeline(**kwargs) retweets = self._api.retweeted_to_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_user_timeline(self, screen_name, **kwargs): return self._api.user_timeline(screen_name, **kwargs) @to_status @include_entities def get_own_timeline(self, **kwargs): me = self.verify_credentials() tweets = self._api.user_timeline(screen_name=me.screen_name, **kwargs) retweets = self._api.retweeted_by_me(**kwargs) tweets.extend(retweets) return tweets @to_status @include_entities def get_mentions(self, **kwargs): return self._api.mentions(**kwargs) @to_status @include_entities def get_favorites(self, **kwargs): return self._api.favorites(**kwargs) @to_direct_message @include_entities def get_direct_messages(self, **kwargs): dms = self._api.direct_messages(**kwargs) sent = self._api.sent_direct_messages(**kwargs) dms.extend(sent) return dms # NOTE: # `get_thread` is not decorated with `to_status` because # it uses `TweepyApi.get_user_timeline` which is already # decorated @include_entities def get_thread(self, status, **kwargs): """ Get the conversation to which `status` belongs. It filters the last tweets by the participanting users and based on mentions to each other. """ author = status.authors_username mentioned = status.mentioned_usernames if author not in mentioned: mentioned.append(author) tweets = [] for username in mentioned: tweets.extend(self.get_user_timeline(username, **kwargs)) def belongs_to_conversation(status): for username in mentioned: if username in status.text: return True return filter(belongs_to_conversation, tweets) @to_status_from_search @include_entities def search(self, text, **kwargs): return self._api.search(text, **kwargs) @to_status @include_entities def get_retweets_of_me(self, **kwargs): return self._api.retweets_of_me(**kwargs) def update(self, text): self._api.update_status(text) def destroy_status(self, status): self._api.destroy_status(status.id) def retweet(self, status): self._api.retweet(status.id) def direct_message(self, username, text): self._api.send_direct_message(user=username, text=text) def destroy_direct_message(self, dm): self._api.destroy_direct_message(dm.id) def create_friendship(self, screen_name): self._api.create_friendship(screen_name=screen_name) def destroy_friendship(self, screen_name): self._api.destroy_friendship(screen_name=screen_name) def create_favorite(self, status): self._api.create_favorite(status.id) def destroy_favorite(self, status): self._api.destroy_favorite(status.id) # list methods @to_list def get_lists(self, screen_name): return self._api.lists(screen_name) @to_list def get_own_lists(self): return self._api.lists() @to_list def get_list_memberships(self): return self._api.lists_memberships() @to_list def get_list_subscriptions(self): return self._api.lists_subscriptions() @to_status def get_list_timeline(self, a_list): owner = a_list.owner.screen_name return self._api.list_timeline(owner=owner, slug=a_list.slug) @to_user def get_list_members(self, a_list): owner = a_list.owner.screen_name return self._api.list_members(owner=owner, slug=a_list.slug) def is_list_member(self, user, a_list): return bool(self._api.is_list_member(owner=user.screen_name, slug=a_list.slug, user_id=user.id,)) @to_list def subscribe_to_list(self, a_list): owner = a_list.owner return self._api.subscribe_list(owner=owner.screen_name, slug=a_list.slug) @to_user def get_list_subscribers(self, a_list): owner = a_list.owner return self._api.list_subscribers(owner=owner.screen_name, slug=a_list.slug,) def is_list_subscriber(self, user, a_list): return bool(self._api.is_subscribed_list(owner=user.screen_name, slug=a_list.slug, user_id=user.id,))
class TweepyApi(BaseTweepyApi, Api): """ A `Api` implementation using `tweepy` library. http://github.com/tweepy/tweepy/ """ def __init__(self, *args, **kwargs): Api.__init__(self, *args, **kwargs) # conversion to `turses.models` def _to_status(self, statuses): def to_status(status): kwargs = { 'id': status.id, 'created_at': status.created_at, 'user': status.user.screen_name, 'text': status.text, } return Status(**kwargs) if isinstance(statuses, list): return [to_status(status) for status in statuses] else: return to_status(statuses) def _to_direct_message(self, dms): def to_direct_message(dm): kwargs = { 'id': dm.id, 'created_at': dm.created_at, 'sender_screen_name': dm.sender_screen_name, 'recipient_screen_name': dm.recipient_screen_name, 'text': dm.text, } return DirectMessage(**kwargs) if isinstance(dms, list): return [to_direct_message(dm) for dm in dms] else: return to_direct_message(dms) def _to_list(self, lists): def to_list(l): created_at = datetime_from_twitter_datestring(l.created_at) if l.mode == u'private': private = True else: private = False kwargs = { 'id': l.id, 'owner': l.user.screen_name, 'created_at': created_at, 'name': l.name, 'description': l.description, 'member_count': l.member_count, 'subscriber_count': l.subscriber_count, 'private': private, } return List(**kwargs) if isinstance(lists, list): return [to_list(l) for l in lists] else: return to_list(lists) # from `turses.api.base.Api` def init_api(self): oauth_handler = TweepyOAuthHandler(self._consumer_key, self._consumer_secret) oauth_handler.set_access_token(self._access_token_key, self._access_token_secret) self._api = BaseTweepyApi(oauth_handler) def verify_credentials(self): def to_user(user): kwargs = { 'screen_name': user.screen_name, } return User(**kwargs) return to_user(self._api.me()) # timelines def get_home_timeline(self, **kwargs): tweets = self._api.home_timeline(**kwargs) retweets = self._api.retweeted_to_me(**kwargs) tweets.extend(retweets) return self._to_status(tweets) def get_user_timeline(self, screen_name, **kwargs): return self._to_status(self._api.user_timeline(screen_name, **kwargs)) def get_own_timeline(self, **kwargs): me = self.verify_credentials() tweets = self._api.user_timeline(screen_name=me.screen_name, **kwargs) retweets = self._api.retweeted_by_me(**kwargs) tweets.extend(retweets) return self._to_status(tweets) def get_mentions(self, **kwargs): return self._to_status(self._api.mentions(**kwargs)) def get_favorites(self, **kwargs): return self._to_status(self._api.favorites(**kwargs)) def get_direct_messages(self, **kwargs): dms = self._api.direct_messages(**kwargs) sent = self._api.sent_direct_messages(**kwargs) dms.extend(sent) return self._to_direct_message(dms) def get_thread(self, status, **kwargs): author = get_authors_username(status) mentioned = get_mentioned_usernames(status) if author not in mentioned: mentioned.append(author) tweets = [] for username in mentioned: tweets.extend(self.get_user_timeline(username, **kwargs)) def belongs_to_conversation(status): for username in mentioned: if username in status.text: return True return filter(belongs_to_conversation, tweets) def get_search(self, text, **kwargs): # `tweepy.API.search` returns `tweepy.models.SearchResult` objects instead # `tweepy.models.Status` so we have to convert them differently def to_status(status): kwargs = { 'id': status.id, 'created_at': status.created_at, 'user': status.from_user, 'text': status.text, } return Status(**kwargs) results = self._api.search(text, **kwargs) return [to_status(result) for result in results] def update(self, text): return self._api.update_status(text) def destroy_status(self, status): return self._to_status(self._api.destroy_status(status.id)) def retweet(self, status): return self._to_status(self._api.retweet(status.id)) def direct_message(self, username, text): return self._to_direct_message( self._api.send_direct_message(user=username, text=text)) def destroy_direct_message(self, dm): return self._to_direct_message(self._api.destroy_direct_message(dm.id)) # TODO: convert to `turses.models.User` def create_friendship(self, screen_name): self._api.create_friendship(screen_name=screen_name) def destroy_friendship(self, screen_name): self._api.destroy_friendship(screen_name=screen_name) def create_favorite(self, status): self._to_status(self._api.create_favorite(status.id)) def destroy_favorite(self, status): self._to_status(self._api.destroy_favorite(status.id)) # list methods def get_lists(self, screen_name): raise NotImplementedError def get_own_lists(self): raise NotImplementedError def get_list_memberships(self): raise NotImplementedError def get_list_subscriptions(self): raise NotImplementedError def get_list_timeline(self, list): raise NotImplementedError def get_list_members(self, list): raise NotImplementedError def is_list_member(self, user, list): raise NotImplementedError def subscribe_to_list(self, list): raise NotImplementedError def get_list_subscribers(self, list): raise NotImplementedError def is_list_subscriber(self, user, list): raise NotImplementedError
myfile.write("\nList of All Favorites of User " + user) for i in user_favorites: write_into_file_Status(i) print("Successfully implemented favorites") ###############---------create_favorite-------##################### #Favorites the status specified in the ID parameter as the authenticating user. #return Status Object #code 139 you have already favorite the status status_id = "800405530401353728" status_of_favorite = api.create_favorite(status_id) write_into_file_func("create_favorite") myfile.write("\nGiven Message is add to Favorite of Authenticated User") write_into_file_Status(status_of_favorite) print("Successfully implemented create_favorite") ###############---------destroy_favorite-------##################### #UnFavorites the status specified in the ID parameter as the authenticating user. #return Status Object status_id = "860791905831006208" status_of_unfavorite = api.destroy_favorite(status_id)
class TweepyAPITests(unittest.TestCase): def setUp(self): auths = [] for consumer_key, consumer_secret, access_key, access_secret in oauth_keys: auth = OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_key, access_secret) auths.append(auth) self.api = API(auths) self.api.retry_count = 2 self.api.retry_delay = 5 # TODO: Actually have some sort of better assertion def testgetoembed(self): data = self.api.get_oembed(test_tweet_id) self.assertEqual(data["author_name"], "Twitter") def testhometimeline(self): self.api.home_timeline() def testusertimeline(self): self.api.user_timeline() self.api.user_timeline("twitter") def testmentionstimeline(self): self.api.mentions_timeline() def testretweetsofme(self): self.api.retweets_of_me() def testretweet(self): # TODO(josh): Need a way to get random tweets to retweet. raise SkipTest() def testretweets(self): self.api.retweets(test_tweet_id) def testgetstatus(self): self.api.get_status(id=test_tweet_id) def testupdateanddestroystatus(self): # test update text = "testing %i" % random.randint(0, 1000) update = self.api.update_status(status=text) self.assertEqual(update.text, text) # test destroy deleted = self.api.destroy_status(id=update.id) self.assertEqual(deleted.id, update.id) def testgetuser(self): u = self.api.get_user("twitter") self.assertEqual(u.screen_name, "twitter") u = self.api.get_user(783214) self.assertEqual(u.screen_name, "twitter") def testsearchusers(self): self.api.search_users("twitter") def testsuggestedcategories(self): self.api.suggested_categories() def testsuggestedusers(self): categories = self.api.suggested_categories() if len(categories) != 0: self.api.suggested_users(categories[0].slug) def testsuggesteduserstweets(self): categories = self.api.suggested_categories() if len(categories) != 0: self.api.suggested_users_tweets(categories[0].slug) def testme(self): me = self.api.me() self.assertEqual(me.screen_name, username) def testdirectmessages(self): self.api.direct_messages() def testsentdirectmessages(self): self.api.sent_direct_messages() def testsendanddestroydirectmessage(self): # send sent_dm = self.api.send_direct_message(username, text="test message") self.assertEqual(sent_dm.text, "test message") self.assertEqual(sent_dm.sender.screen_name, username) self.assertEqual(sent_dm.recipient.screen_name, username) # destroy destroyed_dm = self.api.destroy_direct_message(sent_dm.id) self.assertEqual(destroyed_dm.text, sent_dm.text) self.assertEqual(destroyed_dm.id, sent_dm.id) self.assertEqual(destroyed_dm.sender.screen_name, username) self.assertEqual(destroyed_dm.recipient.screen_name, username) def testcreatedestroyfriendship(self): enemy = self.api.destroy_friendship("twitter") self.assertEqual(enemy.screen_name, "twitter") # Wait 5 seconds to allow Twitter time # to process the friendship destroy request. sleep(5) friend = self.api.create_friendship("twitter") self.assertEqual(friend.screen_name, "twitter") def testshowfriendship(self): source, target = self.api.show_friendship(target_screen_name="twtiter") self.assert_(isinstance(source, Friendship)) self.assert_(isinstance(target, Friendship)) def testfriendsids(self): self.api.friends_ids(username) def testfollowersids(self): self.api.followers_ids(username) def testfriends(self): self.api.friends(username) def testfollowers(self): self.api.followers(username) def testverifycredentials(self): self.assertNotEqual(self.api.verify_credentials(), False) # make sure that `me.status.entities` is not an empty dict me = self.api.verify_credentials(include_entities=True) self.assertTrue(me.status.entities) # `status` shouldn't be included me = self.api.verify_credentials(skip_status=True) self.assertFalse(hasattr(me, "status")) def testratelimitstatus(self): self.api.rate_limit_status() """ TODO(josh): Remove once this deprecated API is gone. def testsetdeliverydevice(self): self.api.set_delivery_device('im') self.api.set_delivery_device('none') """ def testupdateprofilecolors(self): original = self.api.me() updated = self.api.update_profile_colors("000", "000", "000", "000", "000") # restore colors self.api.update_profile_colors( original.profile_background_color, original.profile_text_color, original.profile_link_color, original.profile_sidebar_fill_color, original.profile_sidebar_border_color, ) self.assertEqual(updated.profile_background_color, "000000") self.assertEqual(updated.profile_text_color, "000000") self.assertEqual(updated.profile_link_color, "000000") self.assertEqual(updated.profile_sidebar_fill_color, "000000") self.assertEqual(updated.profile_sidebar_border_color, "000000") """ def testupateprofileimage(self): self.api.update_profile_image('examples/profile.png') def testupdateprofilebg(self): self.api.update_profile_background_image('examples/bg.png') """ def testupdateprofile(self): original = self.api.me() profile = { "name": "Tweepy test 123", "url": "http://www.example.com", "location": "pytopia", "description": "just testing things out", } updated = self.api.update_profile(**profile) self.api.update_profile( name=original.name, url=original.url, location=original.location, description=original.description ) for k, v in profile.items(): if k == "email": continue self.assertEqual(getattr(updated, k), v) def testfavorites(self): self.api.favorites() def testcreatedestroyfavorite(self): self.api.create_favorite(4901062372) self.api.destroy_favorite(4901062372) def testcreatedestroyblock(self): self.api.create_block("twitter") self.api.destroy_block("twitter") self.api.create_friendship("twitter") # restore def testblocks(self): self.api.blocks() def testblocksids(self): self.api.blocks_ids() def testcreateupdatedestroylist(self): params = {"owner_screen_name": username, "slug": "tweeps"} l = self.api.create_list(name=params["slug"], **params) l = self.api.update_list(list_id=l.id, description="updated!") self.assertEqual(l.description, "updated!") self.api.destroy_list(list_id=l.id) def testlistsall(self): self.api.lists_all() def testlistsmemberships(self): self.api.lists_memberships() def testlistssubscriptions(self): self.api.lists_subscriptions() def testlisttimeline(self): self.api.list_timeline("applepie", "stars") def testgetlist(self): self.api.get_list(owner_screen_name="applepie", slug="stars") def testaddremovelistmember(self): params = {"slug": "test", "owner_screen_name": username, "screen_name": "twitter"} def assert_list(l): self.assertEqual(l.name, params["slug"]) assert_list(self.api.add_list_member(**params)) assert_list(self.api.remove_list_member(**params)) def testlistmembers(self): self.api.list_members("applepie", "stars") def testshowlistmember(self): self.assertTrue( self.api.show_list_member(owner_screen_name="applepie", slug="stars", screen_name="NathanFillion") ) def testsubscribeunsubscribelist(self): params = {"owner_screen_name": "applepie", "slug": "stars"} self.api.subscribe_list(**params) self.api.unsubscribe_list(**params) def testlistsubscribers(self): self.api.list_subscribers("applepie", "stars") def testshowlistsubscriber(self): self.assertTrue(self.api.show_list_subscriber("applepie", "stars", username)) def testsavedsearches(self): s = self.api.create_saved_search("test") self.api.saved_searches() self.assertEqual(self.api.get_saved_search(s.id).query, "test") self.api.destroy_saved_search(s.id) def testsearch(self): self.api.search("tweepy") def testgeoapis(self): def place_name_in_list(place_name, place_list): """Return True if a given place_name is in place_list.""" return any([x.full_name.lower() == place_name.lower() for x in place_list]) twitter_hq = self.api.geo_similar_places(lat=37, long=-122, name="Twitter HQ") # Assumes that twitter_hq is first Place returned... self.assertEqual(twitter_hq[0].id, "3bdf30ed8b201f31") # Test various API functions using Austin, TX, USA self.assertEqual(self.api.geo_id(id="c3f37afa9efcf94b").full_name, "Austin, TX") self.assertTrue( place_name_in_list("Austin, TX", self.api.reverse_geocode(lat=30.267370168467806, long=-97.74261474609375)) ) # Austin, TX, USA