def callback(request):
oauth = tweepy.OAuth1UserHandler(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
callback=None)
# get the request token from the session cookie (then remove from cookie)
session_token = request.session['request_token_tw']
request.session.delete('request_token_tw')
oauth.request_token = {
"oauth_token": session_token[0],
"oauth_token_secret": session_token[1]
}
verifier = request.GET.get('oauth_verifier')
# get the access token and store
try:
access_token, access_token_secret = oauth.get_access_token(verifier)
except tweepy.TweepyException:
print('Error, failed to get access token')
try:
request.session['access_token_tw'] = access_token
request.session['access_token_secret_tw'] = access_token_secret
except Exception:
return redirect('home')
return redirect('home')
def getFollowList(token,target):
auth = tweepy.OAuth1UserHandler(constants.TWITTER_CONSUMER_KEY, constants.TWITTER_CONSUMER_SECRET)
auth.set_access_token(*token)
try:
twitterApi = tweepy.API(auth,proxy=os.environ['HTTPS_PROXY'])
except KeyError:
twitterApi = tweepy.API(auth)
ret = []
try:
user = twitterApi.get_user(screen_name=target)
friendsCount = user.friends_count
friends = tweepy.Cursor(twitterApi.get_friends,screen_name=target,include_user_entities=False,skip_status=True,count=200).items()
for friend in friends:
ret.append(friend.screen_name)
return ret
except tweepy.TooManyRequests:
log.error("rateLimitError")
return ret
except tweepy.TweepyException as e:
log.error(e)
log.error("%s" %(e.response))
simpleDialog.errorDialog(_("Twitterからフォローリストを取得できませんでした。指定したユーザが存在しないか、フォローしていない非公開アカウントである可能性があります。"))
return None
except Exception as e:
log.error(e)
simpleDialog.errorDialog(_("Twitterからフォローリストを取得できませんでした。しばらくたってから再度お試しください。状況が改善しない場合には、開発者までお問い合わせください。"))
return None
def send_temperature_tweet(temperature: float,
isotime: str) -> Tuple[bool, str]:
logger = create_logger(inspect.currentframe().f_code.co_name)
temperature = round(temperature, 2)
fromtime = datetime.fromisoformat(isotime.replace("Z", ""))
utctime = datetime(fromtime.year,
fromtime.month,
fromtime.day,
fromtime.hour,
fromtime.minute,
fromtime.second,
tzinfo=zoneinfo.ZoneInfo("UTC"))
time = utctime.astimezone(zoneinfo.ZoneInfo("Europe/Berlin"))
time_formatted = time.strftime("%H:%M %d.%m.%Y")
now = datetime.now(tz=timezone.utc).astimezone(
zoneinfo.ZoneInfo("Europe/Berlin"))
diff_minutes = (now - time).total_seconds() / 60
logger.debug(f"time: {time} | now: {now} | diff (min): {diff_minutes}")
if diff_minutes > 115:
return False, "last timestamp is older than 115 minutes"
auth = tweepy.OAuth1UserHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = tweepy.API(auth)
if not api.verify_credentials():
return False, "Couldn't verify credentials"
message = f"Der Woog hat eine Temperatur von {temperature}°C ({time_formatted}) #woog #wooglife #darmstadt"
logger.debug(f"updating status with: `{message}`")
api.update_status(message)
return True, ""
def __init__(self, env: Env) -> None:
_auth = tweepy.OAuth1UserHandler(
consumer_key=env.consumer_key,
consumer_secret=env.consumer_secret,
access_token=env.access_token,
access_token_secret=env.access_token_secret,
callback=None)
self.api = tweepy.API(_auth)
def test_tweepy_connection():
try:
auth = tweepy.OAuth1UserHandler(TWITTCK, TWITTST, TWITTAT, TWITTTS)
# Create API object
api = tweepy.API(auth)
except Exception as e:
pass
assert api.verify_credentials().screen_name == 'ra_completion'
def __init__(self):
self.conn = sqlite3.connect(config.dbname)
self.c = self.conn.cursor()
self.tweepy_auth = tweepy.OAuth1UserHandler(
config.consumer_key,
config.consumer_secret,
config.access_token_key,
config.access_token_secret,
)
self.api = tweepy.API(self.tweepy_auth, wait_on_rate_limit=True, retry_count=5, retry_delay=65, retry_errors=(500, 502, 503, 504))
self.api.session = requests_session
def _authenticate(config):
"""Authenticate an user using a consumer key and consumer secret"""
at = config["access_token"]
ats = config["access_token_secret"]
ck = config["consumer_key"]
cs = config["consumer_secret"]
auth = tw.OAuth1UserHandler(consumer_key=ck,
consumer_secret=cs,
access_token=at,
access_token_secret=ats)
return tw.API(auth)
def auth():
config = getConfig()
auth = tweepy.OAuth1UserHandler(
config.get("secrets", "consumer_key"),
config.get("secrets", "consumer_secret"),
config.get("secrets", "access_token"),
config.get("secrets", "access_token_secret"))
api = tweepy.API(auth)
return api
def test_tweepy_limits_mentions():
try:
auth = tweepy.OAuth1UserHandler(TWITTCK, TWITTST, TWITTAT, TWITTTS)
# Create API object
api = tweepy.API(auth)
except Exception as e:
pass
mentions = api.rate_limit_status(
)['resources']['statuses']['/statuses/mentions_timeline']
assert mentions['remaining'] > 0
def login(request):
callback = request.build_absolute_uri(reverse('callback'))
oauth = tweepy.OAuth1UserHandler(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
callback=callback)
auth_url = oauth.get_authorization_url(False)
request.session['request_token_tw'] = (
oauth.request_token["oauth_token"],
oauth.request_token["oauth_token_secret"])
return redirect(auth_url)
def __init__(self, credentials, wait_on_rate_limit=True, enable_v2=False):
self.enable_v2 = enable_v2
self._check_credentials(credentials)
auth = tweepy.OAuth1UserHandler(credentials["api_key"],
credentials["api_secret"],
credentials["access_token"],
credentials["access_token_secret"])
self.api = tweepy.API(auth, wait_on_rate_limit=True)
if self.enable_v2:
self.client = tweepy.Client(credentials["bearer_token"])
else:
self.client = None
def create_api():
"""
This function collects the consumer and access keys, creates an api object and returns the authenticated api
object.
:return: authenticated api object
"""
authentication = tweepy.OAuth1UserHandler(CONSUMER_KEY, CONSUMER_SECRET,ACCESS_TOKEN,ACCESS_TOKEN_SECRET)
api = tweepy.API(authentication, wait_on_rate_limit=True,retry_count=3, retry_delay=2)
return api
def authenticate(args):
"""
Authenticate with Twitter and return an authenticated
Twitter() object to use for API calls
"""
# import the config file
cp = configparser.ConfigParser()
cp.read(os.path.expanduser(args.config))
access_token = cp.get('twitter', 'access_token')
access_token_secret = cp.get('twitter', 'access_token_secret')
consumer_secret = cp.get('twitter', 'consumer_secret')
consumer_key = cp.get('twitter', 'consumer_key')
auth = tweepy.OAuth1UserHandler(consumer_key, consumer_secret,
access_token, access_token_secret)
tw = tweepy.API(auth)
return tw
def __init__(self, request, ac_engine, raw_api=False):
'''Initialize spiral engine request and authenticate if applicable'''
self.logged_in = False
self.ac_engine = ac_engine
auth = None
parser = None
cache_prefix = 'NORMAL'
if raw_api:
parser = tweepy.parsers.RawParser()
cache_prefix = 'RAW'
# check if we have a login token
access_token = request.session.get('access_token_tw', None)
access_token_secret = request.session.get('access_token_secret_tw', None)
if access_token and access_token_secret:
auth = tweepy.OAuth1UserHandler(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
access_token=access_token,
access_token_secret=access_token_secret)
self.logged_in = True
else:
auth = tweepy.OAuth2BearerHandler(settings.TWITTER_BEARER_TOKEN)
if settings.API_CACHE == 'memory':
cache = tweepy.MemoryCache(timeout=settings.API_CACHE_TIMEOUT)
elif settings.API_CACHE == 'file':
cache = tweepy.FileCache(cache_dir=settings.API_FILE_CACHE_PATH + "/" + cache_prefix,
timeout=settings.API_CACHE_TIMEOUT)
elif settings.API_CACHE == 'redis':
cache = tweepy.cache.RedisCache(redis.StrictRedis(),
pre_identifier = "tweepy:" + cache_prefix + ":",
timeout=settings.API_CACHE_TIMEOUT)
else:
cache = None
self.api = tweepy.API(auth, cache=cache,
parser=parser)
def get_twitter_api():
"""
Connect to the Twitter API using the credentials supplied in the configuration file
:return:
"""
# Authenticate to Twitter
auth = tweepy.OAuth1UserHandler(
consumer_key=get_twitter_consumer_key(),
consumer_secret=get_twitter_consumer_secret(),
access_token=get_twitter_access_token(),
access_token_secret=get_twitter_access_token_secret())
api = tweepy.API(auth)
try:
api.verify_credentials()
print("Twitter Authentication OK")
except Exception as ex:
print("Error during Twitter authentication: %s" % ex)
return
return api
def __init__(self, consumerKey, consumerSecret, receivePort):
"""
Args:
consumerKey (string): The consumerKey from Twitter developper portal
consumerSecret (string): The consumerSecret from Twitter developper portal
receivedPort (string): The port number to receive request
"""
self.result = None
self.key = consumerKey
self.secret = consumerSecret
self.port = receivePort
self.localServer = None
# generate request URL
self.tweepy = tweepy.OAuth1UserHandler(
self.key, self.secret, "http://localhost:%d" % self.port)
try:
self.url = self.tweepy.get_authorization_url()
except (tweepy.TweepyException, tweepy.HTTPException) as e:
raise Exception(e)
self.startServer()
def main():
auth = tweepy.OAuth1UserHandler(consumer_key, consumer_secret,
access_token, access_token_secret)
api = tweepy.API(auth)
statuses = api.user_timeline(
screen_name=username) # Getting latest tweets from current user
mentions = api.mentions_timeline(
since_id=statuses[0].id
) # Getting the latest mention after the latest tweet from the current user
for s in mentions:
sn = "@" + s.user.screen_name
sid = s.id
m = "Hey! " + sn + ", thanks for reaching out!"
api.update_status(status=m,
in_reply_to_status_id=sid) #Replying to the Tweet
url = "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
webhook = WebhookClient(url)
response = webhook.send(text=sn +
" mentioned you on Twitter. Please check!"
) #Sending message to Slack webhook
return response
import tweepy
consumer_key = ""
consumer_secret = ""
access_token = ""
access_token_secret = ""
auth = tweepy.OAuth1UserHandler(
consumer_key, consumer_secret, access_token, access_token_secret
)
api = tweepy.API(auth)
# Follow every follower of the authenticated user
for follower in tweepy.Cursor(api.get_followers).items():
follower.follow()
def _api(self) -> tweepy.API:
auth = tweepy.OAuth1UserHandler(os.environ['CONSUMER_KEY'],
os.environ['CONSUMER_SECRET'])
auth.set_access_token(os.environ['ACCESS_TOKEN'],
os.environ['ACCESS_TOKEN_SECRET'])
return tweepy.API(auth)
import tweepy
# PIN-based OAuth
# https://developer.twitter.com/en/docs/authentication/oauth-1-0a/pin-based-oauth
# Your app's API/consumer key and secret can be found under the Consumer Keys
# section of the Keys and Tokens tab of your app, under the
# Twitter Developer Portal Projects & Apps page at
# https://developer.twitter.com/en/portal/projects-and-apps
consumer_key = ""
consumer_secret = ""
auth = tweepy.OAuth1UserHandler(consumer_key, consumer_secret)
# This prints a URL that can be used to authorize your app
# After granting access to the app, a PIN to complete the authorization process
# will be displayed
print(auth.get_authorization_url())
# Enter that PIN to continue
verifier = input("PIN: ")
auth.get_access_token(verifier)
api = tweepy.API(auth)
# If the authentication was successful, this should print the
# screen name / username of the account
print(api.verify_credentials().screen_name)
client = WebClient(token=os.environ.get("SLACK_BOT_TOKEN"))
# ID of channel that you want to upload file to
token = os.environ.get("SLACK_BOT_TOKEN")
channel_id = os.environ.get("SLACK_CHANNEL_ID")
"""
json: Format the data to be sent by the Twitter API into JSON
requests: HTTP client
"""
# 各種twitterのKeyをセット CONSUMER_KEY, CONSUMER_SECRET, ACCESS_KEY, ACCESS_KEY_SECRET
CONSUMER_KEY = os.environ.get("CONSUMER_KEY")
CONSUMER_SECRET = os.environ.get("CONSUMER_SECRET")
ACCESS_KEY = os.environ.get("ACCESS_KEY")
ACCESS_KEY_SECRET = os.environ.get("ACCESS_KEY_SECRET")
# tweepyの設定
auth = tweepy.OAuth1UserHandler(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_KEY,
ACCESS_KEY_SECRET)
api = tweepy.API(auth)
class Slack():
"""
Notification Class to configure the settings for the Slack API
"""
def __init__(self, date, ohlcv):
self.__date = date
self.text = self.__format_text(ohlcv)
@property
def date(self):
"""
Property of date to be displayed in Slack text