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 delete_status(api: tweepy.API, status_id: int, log: bool = True) -> None:
import os
from const import ENV_PATH, FAVKILL_LATEST, FAVKILL_TIMESTAMP
if log:
with open(ENV_PATH + FAVKILL_TIMESTAMP, 'a') as log_fp:
log_fp.write(str(status_id) + '\n')
os.remove(ENV_PATH + FAVKILL_LATEST)
os.symlink(FAVKILL_TIMESTAMP, ENV_PATH + FAVKILL_LATEST)
# delete
api.destroy_favorite(status_id)
logger.info('Successfully deleted')
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
"""
Loop over your favorites.
Compare the favorite's date with the threshold.
If the favorite is older than the threshold we delete it.
"""
# https://dev.twitter.com/rest/public/rate-limiting
FIFTEEN_MINUTES = 15*60
RATE_LIMIT = 180
counter, elapsed_time, previous_time = 0, 0, 0
for status in Cursor(api.favorites).items():
if status.created_at < delete_before:
try:
if not dry_run:
api.destroy_favorite(status.id)
print("Un-favorited {}".format(status.id))
print(status.text.encode('utf-8'))
except TweepError as err:
print("Could not un-favorite {}".format(status.id))
finally:
# Sleep for a bit if we exceed the rate limit.
current_time = time.time()
previous_time = previous_time or current_time
elapsed_time = current_time-previous_time
previous_time = current_time
counter += 1
if elapsed_time < FIFTEEN_MINUTES and counter > RATE_LIMIT:
time.sleep(FIFTEEN_MINUTES-elapsed_time)
counter, elapsed_time, previous_time = 0, 0, 0
print("Could not delete {}".format(status.id))
"""
Loop over your favorites.
Compare the favorite's date with the threshold.
If the favorite is older than the threshold we delete it.
"""
# https://dev.twitter.com/rest/public/rate-limiting
FIFTEEN_MINUTES = 15 * 60
RATE_LIMIT = 180
counter, elapsed_time, previous_time = 0, 0, 0
for status in Cursor(api.favorites).items():
if status.created_at < delete_before:
try:
if not dry_run:
api.destroy_favorite(status.id)
print("Un-favorited {}".format(status.id))
print(status.text.encode('utf-8'))
except TweepError as err:
print("Could not un-favorite {}".format(status.id))
finally:
# Sleep for a bit if we exceed the rate limit.
current_time = time.time()
previous_time = previous_time or current_time
elapsed_time = current_time - previous_time
previous_time = current_time
counter += 1
if elapsed_time < FIFTEEN_MINUTES and counter > RATE_LIMIT:
time.sleep(FIFTEEN_MINUTES - elapsed_time)
counter, elapsed_time, previous_time = 0, 0, 0
#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)
write_into_file_func("destroy_favorite")
myfile.write("\nGiven Message is add to UnFavorite of Authenticated User")
write_into_file_Status(status_of_unfavorite)
print("Successfully implemented destroy_favorite")
myfile.close()
except Exception as e:
print("Error Occured. " + str(e) + " Try Again. ")
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
