-
Notifications
You must be signed in to change notification settings - Fork 4
/
twythonaccess.py
119 lines (101 loc) · 4.29 KB
/
twythonaccess.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
# This module provides the api twython object, which is used to access the api
# import time, to enable the sleep function
import time
# Import twython
from twython import Twython
# import the api keys
import apikeys
# import threading, to schedule the reset
from threading import Timer
# import datetime
from datetime import datetime
# import setup to get the screen name
import setup
# time of ast request is used to be able to reset the requests,
# if more than 16 minutes have elapsed between the requests
# get the utc time to not be bothered by summer time
time_of_last_request = datetime.utcnow()
# The api variable is the way to access the api
def authorize():
# if more than 16 minutes have elapsed since last request, the requests can be reset
check_if_requests_can_be_reset()
# Increment number of requests made
global requests_since_last_sleep
requests_since_last_sleep += 1
# authorize
return Twython(apikeys.CONSUMER_KEY, apikeys.CONSUMER_SECRET, apikeys.ACCESS_TOKEN, apikeys.ACCESS_TOKEN_SECRET)
# this method sends a tweet, by first checking with me
def send_tweet(tweet, in_reply_to_status_id=0):
# send tweet
if check_if_requests_are_maximum(14):
# if requests are maximum, then return directly
# this is to not build up a queue in massinvandring_streamer
return
# maybe send it in reply to another tweet
if in_reply_to_status_id == 0:
# standalone tweet
authorize().update_status(status=tweet)
else:
# tweet is a reply
authorize().update_status(status=tweet, in_reply_to_status_id=in_reply_to_status_id)
print("sent tweet: " + tweet)
def send_rant(tweets, in_reply_to_status_id=0):
# send tweets with an interval of 30 secoonds
# if requests are above maximum minus number of tweets, then return directly
# either the entire rant will be sent, or no rant at all
if check_if_requests_are_maximum(15-len(tweets)):
# return false, so the caller will know that the rant wasn't sent this time
return False
# wait for 5 minutes to be more life-like
time.sleep(5*60)
last_status_id = in_reply_to_status_id
for tweet in tweets:
if last_status_id == 0:
# standalone tweet
authorize().update_status(status=tweet)
else:
# tweet is a reply
authorize().update_status(status=tweet, in_reply_to_status_id=last_status_id)
print("sent tweet: " + tweet)
# sleep for 30 seconds
time.sleep(20)
# get the status ad of the newly sent tweet
last_status_id = authorize().get_user_timeline(screen_name=setup.screen_name, count=1, trim_user=True, exclude_replies=False)[0]["id"]
# return true, since the rant was successfully sent
return True
# not sleeping by default
is_sleeping = False
# Store number of requests, so that they won't exceed the rate limit
requests_since_last_sleep = 0
# This method is called every time a request is to be made
# If the requests variable is over limit, the it returns true
# it also sets the bool is_sleeping
# finally, it schedules the bool to be set to false and the requests to be reset after 16 minutess
# if the requests variable isn't over limit, then do nothing
def check_if_requests_are_maximum(limit):
global requests_since_last_sleep
print("Requests since last sleep: " + str(requests_since_last_sleep))
if requests_since_last_sleep >= limit:
# set the is_sleeping to true
if not is_sleeping:
is_sleeping = True
# delay for 16 minutes
Timer(16*60, reset_requests).start()
return True
return False
# if more than 16 minutes hace elapsed since the last request, reset the requests
def check_if_requests_can_be_reset():
global time_of_last_request, requests_since_last_sleep
# use utctime to not have to care about summer time
now_time = datetime.utcnow()
# compare the now_time and last time
# if more than 16 minutes have elapsed, reset the requests
if (now_time - time_of_last_request).total_seconds() > 16*60:
# reset requests
requests_since_last_sleep = 0
# update the last time
time_of_last_request = now_time
# this function resets the requests
def reset_requests():
requests_since_last_sleep = 0
is_sleeping = False