def testbasicauth(self):
auth = BasicAuthHandler(username, password)
# test accessing twitter API
api = API(auth)
s = api.update_status('test %i' % random.randint(1, 1000))
api.destroy_status(s.id)
def tweet(title, url, location=None, parsed_location=None):
auth = OAuthHandler(app.config['TWITTER_CONSUMER_KEY'], app.config['TWITTER_CONSUMER_SECRET'])
auth.set_access_token(app.config['TWITTER_ACCESS_KEY'], app.config['TWITTER_ACCESS_SECRET'])
api = API(auth)
urllength = 23 # Current Twitter standard for HTTPS (as of Oct 2014)
maxlength = 140 - urllength - 1 # == 116
locationtag = u''
if parsed_location:
locationtags = []
for token in parsed_location.get('tokens', []):
if 'geoname' in token and 'token' in token:
locname = token['token'].strip()
if locname:
locationtags.append(u'#' + locname.title().replace(u' ', ''))
locationtag = u' '.join(locationtags)
if locationtag:
maxlength -= len(locationtag) + 1
if not locationtag and location:
# Make a hashtag from the first word in the location. This catches
# locations like 'Anywhere' which have no geonameid but are still valid
locationtag = u'#' + re.split('\W+', location)[0]
maxlength -= len(locationtag) + 1
if len(title) > maxlength:
text = title[:maxlength-1] + u'…'
else:
text = title[:maxlength]
text = text + ' ' + url # Don't shorten URLs, now that there's t.co
if locationtag:
text = text + ' ' + locationtag
api.update_status(text)
def FeedTwitter():
auth = OAuthHandler(CONSUMER_KEY_TWITTER, CONSUMER_SECRET_TWITTER)
auth.set_access_token(ACCESS_TOKEN_TWITTER, ACCESS_TOKEN_SECRET_TWITTER)
api = API(auth)
feed = api.user_timeline(screen_name=CONST_USER_TWITTER, count=COUNT_NUMBER_POST, page=1, include_rts=True)
tweets = []
for t in feed:
if t.in_reply_to_status_id == None:
try:
tweet = {"text": t.text, "text_encoded": t.text, "type": "tweet", "created_time": t.created_at,
"link":"https://twitter.com/"+CONST_USER_LINK_TWITTER+"/status/" + str(t.id),
"link_encoded":urllib.quote_plus("https://twitter.com/"+CONST_USER_LINK_TWITTER+"/status/" + str(t.id)),
"user": {"name": t.user.name, "screen_name": "@" + t.user.screen_name,"profile_image":t.user.profile_image_url}}
if "media" in t.entities:
if t.entities['media'][0]['type'] == 'photo':
tweet["image"] = t.entities['media'][0]['media_url']
else:
pass
#print t.entities['media'][0]['type']
else:
pass
#tweet["image"] = get_randon_image()
tweets.append(tweet)
except Exception, e:
#print(str(e))
pass
def authenticate(self, access_token_key='', access_token_secret='', consumer_key='', consumer_secret=''):
handler = OAuthHandler(consumer_key, consumer_secret)
handler.set_access_token(access_token_key, access_token_secret)
api = API(handler)
twitter_user = api.verify_credentials()
try:
twitter_id = twitter_user.id
except AttributeError:
user = None
else:
try:
user = User.objects.get(username=twitter_id)
except User.DoesNotExist:
user = User.objects.create_user(twitter_id)
profile = user.get_profile()
profile.access_token_key = handler.access_token.key
profile.access_token_secret = handler.access_token.secret
profile.save()
return user
def get_tweets(count=5):
try:
consumer_key = environ['TWITTER_CONSUMER_KEY']
access_token = environ['TWITTER_ACCESS_TOKEN']
consumer_secret = environ['TWITTER_CONSUMER_SECRET']
access_secret = environ['TWITTER_ACCESS_SECRET']
except KeyError:
error("No Twitter credentials were found.")
# We don't have login stuff, bail.
return []
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = API(auth_handler=auth)
try:
statuses = api.user_timeline('pythonglasgow', count=count)
except TweepError:
error("Failed to read timelime.")
return []
tweets = [(status, twitterfy(status.text)) for status in statuses]
return tweets
def unwrapped_callback(self, resp):
if resp is None:
raise LoginCallbackError(_("You denied the request to login"))
# Try to read more from the user's Twitter profile
auth = TwitterOAuthHandler(self.consumer_key, self.consumer_secret)
if self.access_key is not None and self.access_secret is not None:
auth.set_access_token(self.access_key, self.access_secret)
else:
auth.set_access_token(resp['oauth_token'], resp['oauth_token_secret'])
api = TwitterAPI(auth)
try:
twinfo = api.lookup_users(user_ids=[resp['user_id']])[0]
fullname = twinfo.name
avatar_url = twinfo.profile_image_url_https.replace('_normal.', '_bigger.')
except TweepError:
fullname = None
avatar_url = None
return {'userid': resp['user_id'],
'username': resp['screen_name'],
'fullname': fullname,
'avatar_url': avatar_url,
'oauth_token': resp['oauth_token'],
'oauth_token_secret': resp['oauth_token_secret'],
'oauth_token_type': None, # Twitter doesn't have token types
}
class FaveRetweeter(object):
def __init__(self, consumer_key, consumer_secret, access_token, access_token_secret):
self.consumer_key = consumer_key
self.consumer_secret = consumer_secret
self.access_token = access_token
self.access_token_secret = access_token_secret
self._authorize()
def _authorize(self):
oauth_handler = OAuthHandler(self.consumer_key, self.consumer_secret)
oauth_handler.set_access_token(self.access_token, self.access_token_secret)
self.tweepy = API(oauth_handler)
def retweet_fave(self):
me = self.tweepy.me()
favorite_count = me.favourites_count
page = randrange(favorite_count)
favorites = self.tweepy.favorites(count=1, page=page)
favorite = favorites[0]
_retweet(favorite, me)
def __init__(self, term='', oauthfile=''):
threading.Thread.__init__(self)
self.searchterm = term
self.name = term
self.consume = True
listener = MongoDBListener()
try:
oauth = json.loads(open(oauthfile, 'r').read())
if 'consumer_key' in oauth:
auth = OAuthHandler(oauth['consumer_key'], oauth['consumer_secret'])
auth.set_access_token(oauth['access_token'], oauth['access_token_secret'])
api = API(auth)
if not api.verify_credentials():
raise Exception("Invalid credentials")
else:
auth = BasicAuthHandler(oauth['username'], oauth['password'])
except:
print "Error logging to Twitter"
raise
self.stream = Stream(auth, listener, timeout=60)
def unwrapped_callback(self, resp):
if resp is None:
raise LoginCallbackError(_("You denied the request to login"))
# Try to read more from the user's Twitter profile
auth = TwitterOAuthHandler(self.consumer_key, self.consumer_secret)
auth.set_access_token(resp['oauth_token'], resp['oauth_token_secret'])
api = TwitterAPI(auth)
try:
twinfo = api.verify_credentials(include_entities='false', skip_status='true', include_email='true')
fullname = twinfo.name
avatar_url = twinfo.profile_image_url_https.replace('_normal.', '_bigger.')
email = getattr(twinfo, 'email', None)
except TweepError:
fullname = None
avatar_url = None
email = None
return {'email': email,
'userid': resp['user_id'],
'username': resp['screen_name'],
'fullname': fullname,
'avatar_url': avatar_url,
'oauth_token': resp['oauth_token'],
'oauth_token_secret': resp['oauth_token_secret'],
'oauth_token_type': None, # Twitter doesn't have token types
}
class TwitterPlayer(player.Player):
def __init__(self, model, code, access_token, access_token_secret, opponent):
player.Player.__init__(self, model, code)
self._opponent = opponent
self._last_id = None
self._auth = OAuthHandler(auth.consumer_key, auth.consumer_secret)
self._auth.set_access_token(access_token, access_token_secret)
self._api = API(self._auth)
self._listener = TwitterListener(self, self._api)
self._stream = Stream(self._auth, self._listener)
@property
def username(self):
return self._auth.get_username()
def allow(self):
print 'This is the opponent\'s turn...'
self._stream.userstream()
def update(self, event):
if event.player == self.code:
return
message = '@%s %s' % (self._opponent, self._model.events[-1][1])
self.tweet(message)
def tweet(self, message):
if self._last_id is None:
self._api.update_status(message)
else:
self._api.update_status(message, self._last_id)
def tweet(title, url, location=None, parsed_location=None, username=None):
auth = OAuthHandler(app.config["TWITTER_CONSUMER_KEY"], app.config["TWITTER_CONSUMER_SECRET"])
auth.set_access_token(app.config["TWITTER_ACCESS_KEY"], app.config["TWITTER_ACCESS_SECRET"])
api = API(auth)
urllength = 23 # Current Twitter standard for HTTPS (as of Oct 2014)
maxlength = 140 - urllength - 1 # == 116
if username:
maxlength -= len(username) + 2
locationtag = u""
if parsed_location:
locationtags = []
for token in parsed_location.get("tokens", []):
if "geoname" in token and "token" in token:
locname = token["token"].strip()
if locname:
locationtags.append(u"#" + locname.title().replace(u" ", ""))
locationtag = u" ".join(locationtags)
if locationtag:
maxlength -= len(locationtag) + 1
if not locationtag and location:
# Make a hashtag from the first word in the location. This catches
# locations like 'Anywhere' which have no geonameid but are still valid
locationtag = u"#" + re.split("\W+", location)[0]
maxlength -= len(locationtag) + 1
if len(title) > maxlength:
text = title[: maxlength - 1] + u"…"
else:
text = title[:maxlength]
text = text + " " + url # Don't shorten URLs, now that there's t.co
if locationtag:
text = text + " " + locationtag
if username:
text = text + " @" + username
api.update_status(text)
def get_tweets(tweeter_id, from_id = None):
#Setup
#l = StdOutListener()
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
#Get tweets (status) from Twitter A
if from_id == None:
status = api.user_timeline(user_id = tweeter_id, count=amont_of_tweets)
else:
status = api.user_timeline(user_id = tweeter_id, count=amont_of_tweets, max_id = from_id)
status.pop(0) #Remove duplicate first tweet, max_id not included.
tweetlist = []
last_id = 0
#print("Cleaning tweets from :", status.user.screen_name, "id: ", tweeter_id)
for items in status:
tweet = {}
tweet["id"] = items.id
tweet["user_id"] = tweeter_id
tweet["nickname"] = items.user.screen_name
tweet["realname"] = items.user.name
tweet["date"] = datetime.strptime(str(items.created_at), "%Y-%m-%d %H:%M:%S")
tweet["text"] = items.text
tweetlist.append(tweet)
last_id = items.id
print("Last ID: ", last_id, "\n")
return tweetlist, last_id
def get(self, request, *args, **kwargs):
"""
The GET method controller for the API endpoint and saves the results
to a CSV file.
Accepts query strings:
- keyword: the keyword that searched for
- count: number of results retrieved (default = 100)
"""
keyword = request.GET.get('keyword')
count = request.GET.get('count', 100)
if not keyword:
return Response(HTTP_400_BAD_REQUEST)
auth = twitter_auth()
api = API(auth, parser=JSONParser())
data = []
results = api.search(q=keyword, count=count)
filename = 'search_{}_{}.csv'.format(
keyword, datetime.now().isoformat()
)
for result in results['statuses']:
data.append({
'user': parse_tweet(result['user']['name']),
'tweet': parse_tweet(result['text'])
})
save_to_csv(filename, data)
response_text = 'Saved {} objects.'.format(
results['search_metadata']['count']
)
return Response(response_text)
def unwrapped_callback(self, resp):
if resp is None:
raise LoginCallbackError(_("You denied the request to login"))
# Try to read more from the user's Twitter profile
auth = TwitterOAuthHandler(self.consumer_key, self.consumer_secret)
if self.access_key is not None and self.access_secret is not None:
auth.set_access_token(self.access_key, self.access_secret)
else:
auth.set_access_token(resp["oauth_token"], resp["oauth_token_secret"])
api = TwitterAPI(auth)
try:
twinfo = api.lookup_users(user_ids=[resp["user_id"]])[0]
fullname = twinfo.name
avatar_url = twinfo.profile_image_url_https.replace("_normal.", "_bigger.")
except TweepError:
fullname = None
avatar_url = None
return {
"userid": resp["user_id"],
"username": resp["screen_name"],
"fullname": fullname,
"avatar_url": avatar_url,
"oauth_token": resp["oauth_token"],
"oauth_token_secret": resp["oauth_token_secret"],
"oauth_token_type": None, # Twitter doesn't have token types
}
class StreamConsumerThreadClass(threading.Thread):
def __init__(self, term="", oauthfile="", follow=False, user=False, track=False):
threading.Thread.__init__(self)
self.searchterm = term
self.name = term
self.consume = True
self.follow = follow
self.user = user
self.track = track
listener = MongoDBListener()
try:
oauth = json.loads(open(oauthfile, "r").read())
if "consumer_key" in oauth:
auth = OAuthHandler(oauth["consumer_key"], oauth["consumer_secret"])
auth.set_access_token(oauth["access_token"], oauth["access_token_secret"])
self.api = API(auth)
if not self.api.verify_credentials():
raise Exception("Invalid credentials")
self.stream = Stream(auth, listener, timeout=60)
except:
print "Error logging to Twitter"
raise
def stop_consume(self):
self.stream.disconnect()
def run(self):
now = datetime.datetime.now()
if self.user:
print "Twitter Stream of the OAuth user: started at: %s" % (now)
else:
print "Twitter Stream with terms: %s started at: %s" % (self.getName(), now)
connected = False
while True:
try:
if not connected:
connected = True
if self.user:
self.stream.userstream(_with="followings")
elif self.follow:
user_ids = []
for user in self.api.lookup_users([], self.searchterm.split(","), False):
user_ids.append(user.id)
self.stream.filter(follow=[",".join("{0}".format(n) for n in user_ids)])
elif self.track:
self.stream.filter(track=[self.searchterm])
except SSLError, sse:
print sse
connected = False
except Exception, e:
print "Stream error"
raise e
class Twitter():
def __init__(self, config = None):
auth = OAuthHandler(unicode(config.consumerKey), unicode(config.consumerSecret))
auth.set_access_token(unicode(config.accessToken), unicode(config.accessTokenSecret))
self._api = API(auth)
def tweet(self, message):
self._api.update_status(message.encode('utf-8'))
def send_reply(tweetID,screen_name): try: auth = OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) api = API(auth) ### at this point I've grabbed the tweet and loaded it to JSON... status_message = "@%s You are not supposed to use such words. @stophatebot " % (screen_name) api.update_status(status_message, tweetID) except Exception, e: print e
def get_location_trends(locations, auth): api = API(auth) trends = api.trends_place(locations) data = trends[0] trends_data = data['trends'] names = [trend['name'] for trend in trends_data] print names
def main():
try:
auth = OAuthHandler(consumer_key, consumer_secret)
auth.secure = True
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
print(api.me().name)
stream = Stream(auth, StdOutListener())
stream.userstream()
except BaseException as e:
print("Error in main()", e)
class TweetReply():
def __init__(self):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
self.api = API(auth)
def tweet_in_response(self, screen_name, tweet_id, url):
# self.api.update_status("@" + screen_name + " Hi! Could you please click the link to stream your surroundings? " + url, tweet_id)
self.api.update_status("@" + screen_name + " We support you!", tweet_id)
def tweet_to_person(self, screen_name):
# self.api.update_status("@" + screen_name + " Hi! Could you please click the link to stream your surroundings? " + url, tweet_id)
self.api.update_status("@" + screen_name + " Somebody requested a live stream from you: http://streamy.co/streamer/" + screen_name)
def post_gettweets():
page = 1
keyword = bottle.request.forms.get("tweetKeyword")
maxPage = bottle.request.forms.get("pages")
print keyword
print maxPage
results =[]
twitter_api = API()
for page in range(int(maxPage)):
tweets = twitter_api.search(keyword, page=page)
for tweet in tweets:
result.append(tweet)
print len(result)
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 start():
# setup Twitter API connection details
twitter_auth = OAuthHandler( TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET )
twitter_auth.set_access_token( TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET )
tweet_api = API(twitter_auth)
public_tweets = tweet_api.home_timeline(count = 1) #count=1 to read only one tweet
for tweet in public_tweets:
print ('{}'.format(tweet))
def authenticate(self, access_token):
"""
Twitterから取得したアクセストークンをもとに認証を行う。
:param access_token: アクセストークン
:type access_token: tuple
:return: ユーザー情報
:rtype: django.contrib.auth.models.User
"""
# APIオブジェクトを構築する
oauth_handler = OAuthHandler(settings.CONSUMER_KEY, settings.CONSUMER_SECRET)
oauth_handler.set_access_token(access_token[0], access_token[1])
api = API(oauth_handler)
# ログインユーザーのTwitter情報を取得する
try:
twitter_user = api.me()
except TweepError:
return None
# Profile/Userを取得/作成する
try:
profile = Profile.objects.get(twitter_id=twitter_user.id)
user = profile.user
except Profile.DoesNotExist:
# Userを作成する
user = User()
user.username = twitter_user.id
user.first_name = twitter_user.screen_name
user.last_name = twitter_user.name
user.set_unusable_password()
user.save()
# Profileを作成する
profile = Profile()
profile.twitter_id = twitter_user.id
profile.screen_name = twitter_user.screen_name
profile.name = twitter_user.name
profile.description = twitter_user.description
profile.url = twitter_user.url
profile.profile_image_url = twitter_user.profile_image_url
profile.user = user
profile.save()
# 有効なユーザーであるかチェックする
if user.is_active:
return user
else:
return None
class TwitterHandler( StreamListener ):
def __init__( self ):
self.logger = logging.getLogger(__name__)
try:
self.auth = OAuthHandler(twitter_secrets.APP_KEY, twitter_secrets.APP_SECRET)
self.auth.secure = True
self.auth.set_access_token(twitter_secrets.OAUTH_TOKEN, twitter_secrets.OAUTH_TOKEN_SECRET)
self.api = API(self.auth)
# If the authentication was successful, you should
# see the name of the account self.logger.info out
self.logger.info(self.api.me().name)
self.stream = Stream(self.auth, self)
self.stream.userstream(async = True)
except BaseException as e:
self.logger.info("Error in __init__", e)
def on_connect( self ):
self.logger.info("Connection established!!")
def on_disconnect( self, notice ):
self.logger.info("Connection lost!! : ", notice)
def on_data( self, status ):
self.logger.info("Entered on_data()")
data = json.loads(status)
if 'direct_message' in data:
name = data['direct_message']['sender_screen_name']
text = data['direct_message']['text']
m = models.Message(source = "twitter", name = name, message = text, rec_by = "", response = "")
m.save()
self.logger.info("Name: " + name + " Text: " + text)
return True
def on_error( self, status ):
self.logger.info(status)
def sendMessage( self, name, message):
if(self.api.me().screen_name != name):
self.api.send_direct_message(screen_name = name, text = message)
self.logger.info("successfully sent " + message + " to " + name)
else:
self.logger.info("Cannot send message to yourself")
def testoauth(self):
auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret)
# test getting access token
auth_url = auth.get_authorization_url()
print('Please authorize: ' + auth_url)
verifier = raw_input('PIN: ').strip()
self.assert_(len(verifier) > 0)
access_token = auth.get_access_token(verifier)
self.assert_(access_token is not None)
# build api object test using oauth
api = API(auth)
s = api.update_status('test %i' % random.randint(0, 1000))
api.destroy_status(s.id)
def update_status(text):
try:
consumer_key = environ['TWITTER_CONSUMER_KEY']
access_token = environ['TWITTER_ACCESS_TOKEN']
consumer_secret = environ['TWITTER_CONSUMER_SECRET']
access_secret = environ['TWITTER_ACCESS_SECRET']
except KeyError:
error("No Twitter credentials were found.")
# We don't have login stuff, bail.
return
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = API(auth_handler=auth)
api.update_status(status=text)
def send_dm(username, text):
try:
consumer_key = environ['TWITTER_CONSUMER_KEY']
access_token = environ['TWITTER_ACCESS_TOKEN']
consumer_secret = environ['TWITTER_CONSUMER_SECRET']
access_secret = environ['TWITTER_ACCESS_SECRET']
except KeyError:
error("No Twitter credentials were found.")
# We don't have login stuff, bail.
return
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = API(auth_handler=auth)
api.send_direct_message(screen_name=username, text=text)
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'])
def start():
global redis_conn
redis_conn = redis.StrictRedis(host="localhost", port=6379, db=0)
consumer_key = config.get("twitter", "client_id")
consumer_secret = config.get("twitter", "client_secret")
access_token = config.get("twitter", "access_token")
access_token_secret = config.get("twitter", "access_token_secret")
l = StdOutListener()
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
friend_ids = api.friends_ids()
stream = Stream(auth, l)
# ,track=['startup','entrepreneurship','marketing','SEO']
stream.filter(follow=friend_ids, track=["clojure"]) # ,track=[
class Twitter:
'''
:param credential: class that contains objects like administrator_data -> object
'''
def __init__(self, credential):
'''
initialize twitter with tweepy
Attributes:
- credential
- api
- AdminCmd
- UserCmd
- me
- follower
- followed
- random_time
- db_sent
- day
- db_received
- indicator_start
- db_intervalTime
:param credential: class that contains objects like administrator_data -> object
'''
self.credential = credential
print("Initializing twitter...")
auth = OAuthHandler(
credential.CONSUMER_KEY, credential.CONSUMER_SECRET)
auth.set_access_token(
credential.ACCESS_KEY, credential.ACCESS_SECRET)
self.api = API(
auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
self.AdminCmd = AdminCommand(self.api, credential)
self.UserCmd = UserCommand(self.api, credential)
self.me = self.api.me()
self.follower = list() # list of integer
self.followed = list() # list of integer
self.random_time = credential.Delay_time
self.db_sent = dict() # dict of sender and his postid, update every midnight with self.day
self.day = (datetime.now(timezone.utc) + timedelta(hours=credential.Timezone)).day
self.db_received = list() # list of 55 received menfess's message id
self.indicator_start = False
self.db_intervalTime = dict()
def get_all_followers(self, user_id, first_delay=True):
'''Return all followers ids
Twitter API limiting to get 5000 followers/minute
:param user_id: User id -> int or str
:param first_delay: False: delete delay for first operation -> bool
:returns: list of followers ids integer
'''
try:
print("Getting all followers ids...")
ids = list()
for page in Cursor(self.api.followers_ids, user_id=user_id).pages():
ids.extend(page)
if first_delay is False:
first_delay = True
continue
sleep(60)
return ids
except Exception as ex:
pass
print(ex)
sleep(60)
return list()
def get_all_followed(self, user_id, first_delay=True):
'''Get all account ids that followed by screen_name
Twitter api limiting to get 5000 followed/minute
:param user_id: user id -> str or int
:param first_delay: False: delete delay for first operation -> bool
:returns: list of followers ids integer
'''
try:
print("Getting all friends ids...")
ids = list()
for page in Cursor(self.api.friends_ids, user_id=user_id).pages():
ids.extend(page)
if first_delay is False:
first_delay = True
continue
sleep(60)
return ids
except Exception as ex:
pass
print(ex)
sleep(60)
return list()
def db_sent_updater(self, action, sender_id=None, postid=None):
'''Update self.db_sent
:param action: 'update','add' or 'delete' -> str
:param sender_id: sender id who has sent the menfess -> str
:param postid: tweet id or (sender_id, tweet id) -> str or tuple
'''
try:
if action == 'update':
day = (datetime.now(timezone.utc) + timedelta(hours=self.credential.Timezone)).day
if day != self.day:
self.day = day
self.db_sent.clear()
elif action == 'add':
if sender_id not in self.db_sent:
self.db_sent[sender_id] = [postid]
else: self.db_sent[sender_id] += [postid]
elif action == 'delete':
self.db_sent[sender_id].remove(postid)
if len(self.db_sent[sender_id]) == 0:
del self.db_sent[sender_id]
except Exception as ex:
pass
print(ex)
def read_dm(self):
'''Read and filter DMs
This method contains AdminCmd and UserCmd that can do exec and
self.db_sent updater.
Filters:
- received dm
- admin & user command
- interval per sender
- account status
- blacklist words
- only followed
- sender requirements
- menfess trigger
- attachment_url
- photo
- video
- animated_gif
:returns: list of dict filtered DMs
'''
# Update db_sent
self.db_sent_updater('update')
print("Getting direct messages...")
dms = list()
try:
api = self.api
dm = api.list_direct_messages(count=50)
# FILL DB_RECEIVED WHEN BOT WAS JUST STARTED (Keep_DM)
if self.indicator_start is False:
self.indicator_start = True
if self.credential.Keep_DM is True:
for x in dm:
self.db_received.append(x.id)
# Ignore messages that received before bot started
return dms
# Check Account_status to make process (after Turned off) faster
if self.credential.Account_status is True:
dm.reverse()
else:
for x in range(len(dm)):
message = dm[x].message_create['message_data']['text'].lower()
if "#switch on" in message:
self.credential.Account_status = True
self.delete_dm(dm[x].id)
self.send_dm(dm[x].message_create['sender_id'],"processed: #switch on")
del dm[x]
dm.reverse()
break
elif any(i in message for i in self.credential.Admin_cmd):
dm.reverse()
break
else:
print("Account status: False; AdminCmd not found")
return dms
for x in range(len(dm)):
sender_id = dm[x].message_create['sender_id'] # str
message_data = dm[x].message_create['message_data']
message = message_data['text']
id = dm[x].id
# Message id is already stored on db_received, the message will be skipped (Keep_DM)
if id in self.db_received:
continue
# Avoid keyword error by skipping bot messages
if sender_id == str(self.me.id):
self.delete_dm(id)
continue
# ADMIN & USER COMMAND
list_command = list(self.credential.Admin_cmd) + list(self.credential.User_cmd)
command = message.split()[0].lower()
if any(i == command for i in list_command):
# delete DM to avoid repeated command
self.delete_dm(id)
AdminCmd = self.AdminCmd #pylint: disable=unused-variable
UserCmd = self.UserCmd #pylint: disable=unused-variable
command, *contents = message.split()
notif = str()
if command.lower() in self.credential.Admin_cmd:
# Manage admin access
if sender_id not in self.credential.Admin_id:
notif = self.credential.Notify_wrongTrigger
self.send_dm(recipient_id=sender_id, text=notif)
continue
else:
pass
print(f"command {command} {str(contents)} in progress...")
dict_command = self.credential.Admin_cmd.copy()
dict_command.update(self.credential.User_cmd)
if len(contents) != 0:
urls = message_data["entities"]["urls"]
for arg in contents:
try:
notif += f"\nprocessed: {command} {arg}"
fix_command = dict_command[command.lower()]
exec(fix_command)
if "urls" in fix_command:
break
except Exception as ex:
pass
print(ex)
notif += f"\nException: {ex}"
else:
try:
notif += f"\nprocessed: {command}"
exec(dict_command[command.lower()])
except Exception as ex:
pass
print(ex)
notif += f"\nException: {ex}"
# Skip notif if '#no_notif' in command's comment
if "#no_notif" in dict_command[command.lower()]:
if "Exception" not in notif:
continue
# Manage notification for user
if sender_id not in self.credential.Admin_id:
if "Exception" not in notif:
notif = self.credential.Notify_userCmdDelete
else:
notif = self.credential.Notify_userCmdDeleteFail
self.send_dm(sender_id, notif)
continue
# ACCOUNT STATUS
if self.credential.Account_status is False:
continue
# Interval time per sender
if self.credential.Interval_perSender is True and sender_id not in self.credential.Admin_id:
date_now = datetime.now(timezone.utc) + timedelta(hours=self.credential.Timezone)
for i in list(self.db_intervalTime):
# cleaning self.db_intervalTime
if self.db_intervalTime[i] < date_now:
del self.db_intervalTime[i]
if sender_id in self.db_intervalTime:
continue
else:
self.db_intervalTime[sender_id] = date_now + timedelta(seconds=self.credential.Interval_time)
# Delete or store message id to avoid repeated menfess (Keep_DM)
if self.credential.Keep_DM is True:
if len(self.db_received) > 55:
self.db_received.pop(0)
self.db_received.append(id)
else:
self.delete_dm(id)
# ONLY FOLLOWED
if self.credential.Only_followed is True and sender_id not in self.credential.Admin_id:
if int(sender_id) not in self.followed:
self.send_dm(sender_id, self.credential.Notify_notFollowed)
continue
# Minimum lenMenfess
if len(message) < self.credential.Minimum_lenMenfess and sender_id not in self.credential.Admin_id:
self.send_dm(sender_id, self.credential.Notify_senderRequirements)
continue
# SENDER REQUIREMENTS
if self.credential.Sender_requirements is True and sender_id not in self.credential.Admin_id:
indicator = 0
user = (api.get_user(sender_id))._json
# minimum followers
if user['followers_count'] < self.credential.Minimum_followers:
indicator = 1
# minimum age
created_at = datetime.strptime(user['created_at'], '%a %b %d %H:%M:%S +0000 %Y')
now = (datetime.now(timezone.utc) + timedelta(hours=self.credential.Timezone)).replace(tzinfo=None)
if (now-created_at).days < self.credential.Minimum_day:
indicator = 1
if indicator == 1:
self.send_dm(sender_id, self.credential.Notify_senderRequirements)
continue
# BLACKLIST WORDS
list_blacklist = [i.lower() for i in self.credential.Blacklist_words]
if any(i in message.lower() for i in list_blacklist) and sender_id not in self.credential.Admin_id:
try:
print("Skipping blacklist menfess")
notif = self.credential.Notify_blacklistWords
self.send_dm(recipient_id=sender_id, text=notif)
except Exception as ex:
sleep(60)
print(ex)
pass
continue
# MENFESS TRIGGER
if any(j.lower() in message.lower() for j in self.credential.Trigger_word):
print("Getting message -> sender_id: " + str(sender_id))
dict_dms = dict(message=message, sender_id=sender_id,
media_url=None, attachment_urls={'tweet':(None, None),
'media':list()})
# attachment url
urls = message_data['entities']['urls']
for i in urls:
if "twitter.com/" in i['expanded_url'] and "/status/" in i['expanded_url']:
# i['url]: url in text message
# Media
if any(j in i['expanded_url'] for j in ['/video/', '/photo/', '/media/']):
dict_dms['attachment_urls']['media'].append((i['url'], i['expanded_url']))
#i['expanded_url'] e.g https://twitter.com/username/status/123/photo/1
# Tweet
else:
dict_dms['attachment_urls']['tweet'] = (i['url'], i['expanded_url'])
#i['expanded_url'] e.g https://twitter.com/username/status/123?s=19
# attachment media
if 'attachment' in message_data:
media = message_data['attachment']['media']
media_type = media['type']
if media_type == 'photo':
media_url = media['media_url']
elif media_type == 'video':
media_urls = media['video_info']['variants']
temp_bitrate = list()
for varian in media_urls:
if varian['content_type'] == "video/mp4":
temp_bitrate.append((varian['bitrate'], varian['url']))
# sort to choose the highest bitrate
temp_bitrate.sort()
media_url = temp_bitrate[-1][1]
elif media_type == 'animated_gif':
media_url = media['video_info']['variants'][0]['url']
dict_dms['media_url'] = media_url
dms.append(dict_dms)
# WRONG TRIGGER
else:
notif = self.credential.Notify_wrongTrigger
self.send_dm(recipient_id=sender_id, text=notif)
# Send wrong menfess to admin
username = self.get_user_screen_name(sender_id)
notif = message + f"\nstatus: wrong trigger\nfrom: @{username}\nid: {sender_id}"
for admin in self.credential.Admin_id:
self.send_dm(recipient_id=admin, text=notif)
print(str(len(dms)) + " messages collected")
return dms
except Exception as ex:
pass
print(ex)
sleep(60)
return dms
def notify_queue(self, dms):
"""Notify the menfess queue to sender
:param dms: dms that returned from self.read_dm -> list of dict
"""
try:
print("Notifying the queue to sender")
x, y, z = -1, 0, 0
# x is primary time (30 sec); y is queue; z is addition time for media
time = datetime.now(timezone.utc) + timedelta(hours=self.credential.Timezone)
for i in dms:
y += 1
x += (len(i['message']) // 272) + 1
if i['media_url'] != None:
z += 3
if self.credential.Private_mediaTweet is True:
z += len(i['attachment_urls']['media']) * 4
# Delay for the first sender is very quick, so, it won't be notified
if x == 0:
continue
sent_time = time + timedelta(seconds= x*(32+self.random_time) + z)
sent_time = datetime.strftime(sent_time, '%H:%M')
notif = self.credential.Notify_queueMessage.format(str(y), sent_time)
self.send_dm(recipient_id=i['sender_id'], text=notif)
except Exception as ex:
pass
print(ex)
sleep(60)
def delete_dm(self, id):
'''Delete a DM
:param id: message id -> int or str
'''
try:
self.api.destroy_direct_message(id)
except Exception as ex:
print(ex)
sleep(60)
pass
def send_dm(self, recipient_id, text):
'''Send DM and automatically delete the sent DM
:param recipient_id: -> str or int
:param text: -> str
'''
try:
sent = self.api.send_direct_message(recipient_id=recipient_id, text=text)
self.delete_dm(sent.id)
except Exception as ex:
pass
print(ex)
sleep(60)
def get_user_screen_name(self, id):
'''Get username
:param id: account id -> int
:returns: username -> str
'''
try:
user = self.api.get_user(id)
return user.screen_name
except Exception as ex:
pass
print(ex)
sleep(60)
return "Exception"
def download_media(self, media_url, filename=None):
'''Download media from url
:param media_url: url -> string
:param filename: None (default) or filename --> str
:returns: file name (when filename=None) -> str
'''
print("Downloading media...")
oauth = OAuth1(client_key=self.credential.CONSUMER_KEY,
client_secret=self.credential.CONSUMER_SECRET,
resource_owner_key=self.credential.ACCESS_KEY,
resource_owner_secret=self.credential.ACCESS_SECRET)
r = get(media_url, auth=oauth)
if filename == None:
for i in sub("[/?=]", " ", media_url).split():
if search(r"\.mp4$|\.gif$|\.jpg$|\.jpeg$|\.png$|\.webp$", i):
filename = i
break
if filename == None:
raise Exception("filename is not supported, please check the link")
with open(filename, 'wb') as f:
f.write(r.content)
f.close()
print("Download media successfully")
return filename
def add_watermark(self, filename, output=None):
'''Add watermark to photo, then save as output
Only support photo, if other, nothing will happen
:param filename: file name -> str
:param output: output name -> str
:returns: output name -> str
'''
try:
if output == None:
output = filename
file_type = filename.split('.')[-1]
if file_type in "jpg jpeg png webp":
print("Adding watermark...")
adm = self.credential
wm.watermark_text_image(filename, text=adm.Watermark_text,
ratio=adm.Watermark_ratio, pos=adm.Watermark_position,
output=output, color=adm.Watermark_textColor,
stroke_color=adm.Watermark_textStroke, watermark=adm.Watermark_image)
return output
except Exception as ex:
pass
print(ex)
return filename
def upload_media_tweet(self, media_tweet_url):
'''Upload media with (from) media tweet url
Usually when sender want to post more than one media, he will attachs media tweet url.
But the sender's username is mentioned on the bottom of the media.
This method intended to make sender anonym. This return list of media_ids, then
you can add media_ids to other method. Contains watermark module
:param media_tweet_url: media tweet url e.g https://twitter.com/username/status/123/photo/1 -> str
:returns: [(media_id, media_type),] a.k.a media_idsAndTypes -> list
'''
try:
postid = sub(r"[/\.:]", " ", media_tweet_url).split()[-3]
status = self.api.get_status(postid)
media_idsAndTypes = list()
if 'extended_entities' not in status._json:
return list()
print("Uploading media tweet...")
for media in status._json['extended_entities']['media']:
media_type = media['type']
if media_type == 'photo':
media_url = media['media_url']
elif media_type == 'video':
media_urls = media['video_info']['variants']
temp_bitrate = list()
for varian in media_urls:
if varian['content_type'] == "video/mp4":
temp_bitrate.append((varian['bitrate'], varian['url']))
# sort to choose the highest bitrate
temp_bitrate.sort()
media_url = temp_bitrate[-1][1]
elif media_type == 'animated_gif':
media_url = media['video_info']['variants'][0]['url']
filename = self.download_media(media_url)
# Add watermark
if self.credential.Watermark is True:
self.add_watermark(filename)
media_id, media_type = self.upload_media(filename)
remove(filename)
media_idsAndTypes.append((media_id, media_type))
return media_idsAndTypes # e.g [(media_id, media_type), (media_id, media_type), ]
except Exception as ex:
pass
print(ex)
sleep(60)
return list()
def upload_media(self, filename, media_category='tweet'):
'''Upload media with chunk
This method are needed when you want to use media to do something on
twitter. This returns list of media_id, you can attach it to other method
that require media id.
:param filename: -> str
:param media_category: 'tweet' or 'dm'. default to 'tweet'
:returns: media id, media_type -> tuple
'''
mediaupload = MediaUpload(self.credential, filename, media_category)
media_id, media_type = mediaupload.upload_init()
mediaupload.upload_append()
mediaupload.upload_finalize()
return media_id, media_type
def post_tweet(self, tweet, sender_id, media_url=None, attachment_url=None,
media_idsAndTypes=list(), possibly_sensitive=False):
'''Post a tweet, contains watermark module and self.db_sent updater
Per tweet delay is 30s + self.random_time, but the last delay is deleted
:param tweet: -> str
:param sender_id: -> str or int
:param media_url: media url that will be posted -> str
:param attachment_url: url -> str
:param media_idsAndTypes: [(media_ids, media_type),] -> list
:param possibly_sensitive: True when menfess contains sensitive contents -> bool
:returns: tweet id -> str
'''
try:
#### ADD MEDIA_ID AND MEDIA_TYPE TO LIST_MEDIA_IDS ####
# mediaIdsAndTypes e.g. [(media_id, media_type), (media_id, media_type), ]
if media_url != None:
tweet = tweet.split()
tweet = " ".join(tweet[:-1])
filename = self.download_media(media_url)
# Add watermark
if self.credential.Watermark is True:
self.add_watermark(filename)
media_id, media_type = self.upload_media(filename)
# Add attachment media from DM to the first order
media_idsAndTypes.insert(0, (media_id, media_type))
remove(filename)
list_media_ids = [[]] # e.g. [[media_ids],[media_ids],[media_ids]]
temp = 0
while len(media_idsAndTypes) != 0:
if temp == 0:
temp = 1
list_media_ids = list()
media_ids = list()
added = 0
for media_id, media_type in media_idsAndTypes[:4]:
if media_type == 'video' or media_type == 'animated_gif':
if added == 0:
media_ids.append(media_id)
added += 1
break
media_ids.append(media_id)
added += 1
list_media_ids.append(media_ids)
# media_idsAndTypes are dynamic here
media_idsAndTypes = media_idsAndTypes[added:]
#### POST TWEET ####
postid = 0
# postid is the first tweet of the tweets thread
while len(tweet) > 280:
# Making a Thread.
limit = 272
check = tweet[:limit].split()
separator = len(check[-1])
if tweet[limit-1] == " ":
separator += 1
tweet1 = unescape(tweet[:limit-separator]) + '-cont-'
if postid == 0:
print("Making a thread...")
# postid is static after first update.
postid = self.api.update_status(
tweet1, attachment_url=attachment_url, media_ids=list_media_ids[:1][0],
possibly_sensitive=possibly_sensitive).id
postid1 = postid
else:
postid1 = self.api.update_status(
tweet1, in_reply_to_status_id=postid1, auto_populate_reply_metadata=True,
media_ids=list_media_ids[:1][0], possibly_sensitive=possibly_sensitive).id
list_media_ids = list_media_ids[1:] + [[]]
sleep(30+self.random_time)
# tweet are dynamic here
tweet = tweet[limit-separator:]
# Above and below operation differences are on tweet1 and unescape(tweet), also tweet[limit-separator:]
# It's possible to change it to be one function
if postid == 0:
# postid is static after first update.
postid = self.api.update_status(
unescape(tweet), attachment_url=attachment_url, media_ids=list_media_ids[:1][0],
possibly_sensitive=possibly_sensitive).id
postid1 = postid
else:
postid1 = self.api.update_status(
unescape(tweet), in_reply_to_status_id=postid1, auto_populate_reply_metadata=True,
media_ids=list_media_ids[:1][0], possibly_sensitive=possibly_sensitive).id
list_media_ids = list_media_ids[1:] + [[]]
# When media_ids still exists, It will be attached to the subsequent tweets
while len(list_media_ids[0]) != 0: # Pay attention to the list format, [[]]
sleep(30+self.random_time)
print("Posting the rest of media...")
postid1 = self.api.update_status(
in_reply_to_status_id=postid1,
auto_populate_reply_metadata=True, media_ids=list_media_ids[:1][0],
possibly_sensitive=possibly_sensitive).id
list_media_ids = list_media_ids[1:] + [[]]
print('Menfess is posted -> postid:', str(postid))
# ADD TO DB SENT
self.db_sent_updater('add', sender_id, str(postid))
return postid
except Exception as ex:
pass
print(ex)
sleep(60)
return None
from datetime import datetime, date, time, timedelta
from collections import Counter
import sys
# In[96]:
# Step 1 - Authenticate
consumer_key = 'consumer_key'
consumer_secret = 'consumer_secret'
access_token = 'access_token'
access_token_secret = 'access_token_secret'
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
auth_api = API(auth)
# In[117]:
account_list = ['@realDonaldTrump']
# In[170]:
op = {}
# In[171]:
if len(account_list) > 0:
for target in account_list:
item = auth_api.get_user(target)
op["name "] = item.name
def __init__(self):
self.auth = authenticate_twitter_app()
self.twitter_client = API(self.auth)
class Twitter:
"""A helper for talking to Twitter APIs."""
def __init__(self, logs_to_cloud):
self.logs_to_cloud = logs_to_cloud
self.logs = Logs(name="twitter", to_cloud=self.logs_to_cloud)
self.twitter_auth = OAuthHandler(TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET)
self.twitter_auth.set_access_token(TWITTER_ACCESS_TOKEN,
TWITTER_ACCESS_TOKEN_SECRET)
self.twitter_api = API(self.twitter_auth)
def start_streaming(self, callback):
"""Starts streaming tweets and returning data to the callback."""
self.twitter_listener = TwitterListener(
callback=callback, logs_to_cloud=self.logs_to_cloud)
twitter_stream = Stream(self.twitter_auth, self.twitter_listener)
self.logs.debug("Starting stream.")
twitter_stream.filter(follow=[TRUMP_USER_ID])
# If we got here because of an API error, raise it.
if self.twitter_listener.get_error_status():
raise Exception(self.twitter_listener.get_error_status())
def stop_streaming(self):
"""Stops the current stream."""
if not self.twitter_listener:
self.logs.warn("No stream to stop.")
return
self.logs.debug("Stopping stream.")
self.twitter_listener.stop_queue()
def tweet(self, companies, link):
"""Posts a tweet listing the companies, their ticker symbols, and a
quote of the original tweet.
"""
text = self.make_tweet_text(companies, link)
self.logs.info("Tweeting: %s" % text)
self.twitter_api.update_status(text)
def make_tweet_text(self, companies, link):
"""Generates the text for a tweet."""
text = ""
for company in companies:
line = company["name"]
if "root" in company and company["root"]:
line += " (%s)" % company["root"]
ticker = company["ticker"]
line += " $%s" % ticker
if "sentiment" in company:
if company["sentiment"] == 0:
sentiment = EMOJI_SHRUG
else:
if company["sentiment"] > 0:
sentiment = EMOJI_THUMBS_UP
else:
sentiment = EMOJI_THUMBS_DOWN
line += " %s" % sentiment
text += "%s\n" % line
text += link
return text
def get_tweets(self, ids):
"""Looks up metadata for a list of tweets."""
statuses = self.twitter_api.statuses_lookup(ids)
self.logs.debug("Got statuses response: %s" % statuses)
return statuses
def find_list(api: tweepy.API) -> int:
for l in api.lists_all():
if l.name == list_name:
return l.id
print("リスト作成")
return create_list(api)
except ImportError:
print("Some Error Occured in Importing the Modules and Library")
if __name__ == '__main__':
auth = get_twitter_client()
'''
NOTE: user-authentication : 180 queries per access token every 15 minutes
application- authentication : 450 queries every 15 minutes
Here we would be using application- authentication for higher rate limits.
For that we would have to use Tweepy's AppAuthHandler, we would need consumer_key and consumer_secret for that only
'''
auth = AppAuthHandler(consumer_key, consumer_secret)
api = API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
'''
NOTE:
1.The search API returns a maximum of 100 TWEETS per Query.
2.We'll have to wait once our wait limit is reached.
3.If not sure about the limits and want to check the status of your Rate Limit we can use the Tweepy's following method:
print( api.rate_limit_status()['resource']['search'] )
'''
# pprint.pprint(api.rate_limit_status()) # IF YOU WANT TO LOOK ALL THE ATTRIBUTES
print(api.rate_limit_status()['resources']['search'])
'''
We are all set for making the query we'll seprate the mutiple HASHTAGS by using OR.
Note: Try to keep the query less than 140 characters
'''
query_delhi = ' #DelhiSmog OR #Smog OR #myrighttobreathe OR #smog OR #crop Burning OR\
#delhi OR #delhichokes OR #AirPollution OR \
def get_twitter_client():
auth = get_twitter_auth()
client = API(auth)
return client
try:
self.producer.send('twitterstream', data)
except Exception as e:
print(e)
return False
return True
def on_error(self, status_code):
print("Error received in kafka producer")
return True #don't kill the stream
def on_timeout(self):
return True
if __name__ == '__main__':
consumer_key = 'clcZktfmstM96nvSUjFHAa3fX'
consumer_secret = 'c6cQyak6noAb7lFc3j2dXbNHU9IGzzFen0v1EFo6p0cbfz2BDy'
access_token = '1273089309738926086-EGo5KbNZc37wrnjLpxClo56CVMh2n6'
access_token_secret = 'f4lFuCCAB9ApFD0pjELNUYPYdUmOFIAOl85cqW0qn7Awk'
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
stream = Stream(auth, listener=TstreamListener(api))
tracked = ['Vaccine']
stream.filter(track=tracked, languages=['en'])
def __init__(self, twitter_user=None):
self.auth = TwitterAuthenticator().authenticate_twitter_app()
self.twitter_client = API(self.auth)
self.twitter_user = twitter_user
def pull_down_tweets(screen_name):
api = API(auth)
tweets = api.user_timeline(screen_name=screen_name, count=200)
for tweet in tweets:
# print(json.dumps(tweet._json,indent=4))
print(tweet.text)
from time import sleep
from tweepy import OAuthHandler, API
from pprint import pprint
import requests
import re
consumer_key = '' # Input consumer key
consumer_secret = '' # Input secret consumer key
access_token = '' # Input access token
access_token_secret = '' # Input secret access token
auth = OAuthHandler(consumer_key,
consumer_secret) # Input Twitter app credentials
auth.set_access_token(
access_token, access_token_secret) # Initiate connection to Twitter bot
twitterBot = API(auth)
def main():
while True:
todayPop = worldPopulation() # Define the current world population
percent, popChange = populationChange(
todayPop
) # Find the percent change and population change from yesterday to today
twitterBot.update_status(
'Currently there are {0} people on earth. That is a {1} increase since yesterday!'
.format(todayPop, popChange))
sleep(86400) # Pause for 24 hours
def worldPopulation(
class SListener(StreamListener):
def__init__(self, api = None):
self.output = open('tweets_%s.json %
time.strftime('%Y%m%d-%H%M%S'), 'w'')
self.api or API()
def get_trendy(woeid):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
return api.trends_place(woeid)
def auth():
acct_name, consumer_key, consumer_secret, access_token, access_token_secret = get_account_sequential()
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
auth_api = API(auth)
return auth_api
#getting jokes from website
for item in jocking:
jokes.append(item.find_all("p"))
#now code for tweeting
# Credentials to access Twitter API
ACCESS_TOKEN = 'paste your access token here'
ACCESS_SECRET = 'paste your access secret here'
CONSUMER_KEY = 'paste your consumer key here'
CONSUMER_SECRET = 'paste your consumer secret here'
#authenticating twitter API
Auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
Auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)
TwitterBot = API(Auth)
num = 0
while (num < len(jokes)):
try:
if len(jokes[num]) == 1:
TwitterBot.update_status(jokes[num][0].text)
elif len(jokes[num]) == 2:
TwitterBot.update_status(
str(jokes[num][0].text + ' \n' + jokes[num][1].text))
elif len(jokes[num]) == 3:
TwitterBot.update_status(
def tweepy_direct_message():
test_direct_message = json.loads(test_direct_message_json)
test_direct_message['text'] = 'https://twitter.com/fooman/status/12345'
return TweepyDirectMessage.parse(API(), test_direct_message)
#-*- coding:utf8
from secret import *
from tweepy import API, OAuthHandler, TweepError
from time import *
import pip
# If there is no tweepy, it will install the package auto
pip.main(["install","tweepy"])
print("[+] Prepare to start")
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = API(auth)
me = api.me()
last_tweet = {}
print(f"[+] Start Bot - {me.name}")
followers = me.followers_ids()
while True:
print(f"[+] Check {len(followers)} followers")
for follower in followers:
# to response to "Rate Limit exceeded"
sleep(2)
print (d['text'])
##print(data[100])
print('\n\n')
"""
def on_error(self, status):
##print(stasus)
print("ERROR")
if __name__ == '__main__':
listener = StdOutListener()
auth = OAuthHandler(twitter_credentials.CONSUMER_KEY, twitter_credentials.CONSUMER_KEY_SECRET)
auth.set_access_token(twitter_credentials.ACCESS_TOKEN, twitter_credentials.ACCESS_TOKEN_SECRET)
api = API(auth)
trends1 = api.trends_place(23424934)
trends12 = choice(trends1[0]['trends'])
print(trends1[0]['trends'][])
##stream = Stream(auth, listener)
##stream.filter(track = trends12['name'])
##stream.filter(track = ['#KMKapalit'], languages = ['tl'])
##stream.filter(track = ['Duterte'], languages = ['tl'])
def get_twitter_client():
#setup twitter API client
#return tweepy.API object
auth = get_twitter_auth()
client = API(auth)
return client
import time # time library to get current time at the start and end of the program - to show users how long it takes to run
import pydoc # documentation in this program
from datetime import datetime #to manipulate datetime
import praw # this is Reddit API crawler
# ---------------- Authentications for the APIs ----------------
#Variables that contains the user credentials to access Twitter API
access_token = '421663967-Hz4HafUN5RYo82UWqLGmTd6KxPprP90qOsld6aKv' #"mytoken"
access_token_secret = '2Enlm0YjbMvqqfUXqz53rymo0U5hjVKrcMnRMJikG48nb' #"mytokenscret"
consumer_key = 'R79OBgR64Bip8SPPy32A6FlO8' #"consumerkey'
consumer_secret = 'keoB1Qs4NMKpkf1VjhQYaQOqGqsKAJy3HJXug5GRBpo4WSkxzV' #"consumersecret
# Authorization and Authentication - call the API
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth, wait_on_rate_limit=True)
# Authorization and Authentication - to call the praw API
reddit = praw.Reddit(client_id='H75A7tYoO4NU7w',\
client_secret='bzYDpEB6hXe3ZAruahZILgSFReMCxQ',\
user_agent='1009_crawler_asg',\
username='******',\
password='******')
def main():
""" Main Function to call API and the scrap functions for the individual keywords - this will run for 500 rounds with a 500seconds interval between each run.
This would help to update the webpage with more accurate data from the latest tweets.
- Users are allowed to enter their desired number of rounds and tweets that is to be crawled
:exception AssertionError: When user enter number out of range
:exception ValueError: When user entered something not numeric
def create_list(api: tweepy.API) -> int:
return api.create_list(name=list_name, mode="private").id
def __init__(self, user=None, hashtag=''):
self.auth = TwitterAuthenticator().authenticate_twitter_app()
self.api = API(self.auth)
self.user = user
self.hashtag = hashtag + ' -filter:retweets'
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)
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()
return self._api.user_timeline(screen_name=me.screen_name, **kwargs)
@to_status
@include_entities
def get_mentions(self, **kwargs):
return self._api.mentions_timeline(**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
@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_all(screen_name)
@to_list
def get_own_lists(self):
return self._api.lists_all()
@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)
@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 find_friends(api: tweepy.API) -> typing.Set[int]:
return set(
list(tweepy.Cursor(api.friends_ids, user_id=api.me().id).items()))
from tweepy import API, OAuthHandler
import json, time
config = {}
with open("config/data.json") as f:
config = json.loads(f.read())
with open("config/auth.json") as f:
authdata = json.loads(f.read())
auth = OAuthHandler(authdata['consumer_key'], authdata['consumer_secret'])
auth.set_access_token(authdata['access_token'],
authdata['access_token_secret'])
authdata = {}
authdata = "authdata's been wiped. Don't try to gain access this way!"
api = API(auth)
def checkfake(u):
html = "<h2><a href='https://twitter.com/" + u.screen_name + "' target='_blank'>" + u.screen_name + "</a></h2>"
try:
if u.screen_name != config['official']:
retweets = 0
safe = True
print(u.screen_name)
userposts = api.user_timeline(u.id)
for j in userposts:
for k in config['pointsmeanprizes']:
if k in j.text.lower():
if j.text[:4] == "RT @" and config['ignoreretweets']:
retweets += 1
msg['user_place'] = tweet['user']['location']
msg = json.dumps(msg)
print(msg)
producer.produce("test", msg.encode('utf-8'))
return True
def on_error(self, status):
print(status)
env_path = Path('.') / 'local.env'
load_dotenv(dotenv_path=env_path)
consumer_key = os.getenv("CONSUMER_KEY")
consumer_secret = os.getenv("CONSUMER_SECRET")
access_token = os.getenv("ACCESS_TOKEN")
access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")
producer = Producer({'bootstrap.servers': 'localhost:9092'})
listener = StdOutListener()
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
stream = Stream(auth, listener)
stream.filter(track=['#coronapocalypse'])
'bacon', 'pastel', 'tarta', 'galletas', 'bebida energética',
'perrito caliente', 'helado', 'pizza', 'frito', 'cerveza',
'hamburguesa', 'kebab', 'refresco', 'fastfood', 'vodka', 'whiskey',
'ron', 'tequila', 'sandwich', 'ginebra', 'anís', 'brandy', 'nuggets'
]
stream_args = marcas + food_keywords
if not os.path.isdir('pid'):
os.makedirs('pid')
pid_file = 'pid/pidSpanishGenericTweets'
file = open(pid_file, 'w')
file.write(str(os.getpid()))
file.close()
#Creo el Listener:
# - Con el directorio donde colocar los tweets
# - Y con el tiempo de crear un fichero nuevo
listener = FileListener(output_directory, 3600)
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
logger.warning("Connecting Process Spanish")
api = API(auth)
logger.warning(api.me().name)
stream = Stream(auth=auth, listener=listener)
try:
stream.filter(locations=spain) #, track=stream_args)
except Exception as e:
#SEND A EMAIL
logger.error('Failed to upload to ftp: ' + str(e))
def __init__(self,
twitter_user=None
): # if it is none it will go to default user_timeline
self.auth = TwitterAuthenticator().authenticate_twitter_app()
self.twitter_client = API(self.auth)
self.twitter_user = twitter_user
from tweepy import API, Cursor, OAuthHandler, TweepError
# Read in configs
configs = configparser.ConfigParser()
configs.read('./config.ini')
keys = configs['TWITTER']
consumer_key = keys['CONSUMER_KEY']
consumer_secret = keys['CONSUMER_SECRET']
access_token = keys['ACCESS_TOKEN']
access_secret = keys['ACCESS_SECRET']
screen_name = keys['SCREEN_NAME']
# Authenticate Tweepy connection with Twitter API
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
# Get Twitter ID for each follower
ids = []
for fid in Cursor(api.followers_ids, screen_name=screen_name,
count=5000).items():
ids.append(fid)
# print(ids)
# Get more details for each follower
info = []
for i in range(0, len(ids), 100):
try:
chunk = ids[i:i + 100]
info.extend(api.lookup_users(user_ids=chunk))
def __init__(self, twitter_user, fetched_tweets_filename):
self.auth = TwitterAuthenticator().authenticate_twitter_app()
self.twitter_client = API(self.auth, wait_on_rate_limit=True)
self.twitter_user = twitter_user
self.fetched_tweets_filename = fetched_tweets_filename
