def __init__(self,
site,
conf,
bearer_token=None,
get_token=False,
streaming=False,
upload=False):
self.site = site.lower()
self.conf = conf[site.upper()]
# Identi.ca service only supported for commands "ping" and "microblog"
if self.site == "identica":
self.domain = "identi.ca"
# New Pump.io Identi.ca connection:
self.user = "******" % (self.conf['USER'].lower(), self.domain)
from gazouilleur.identica_auth_config import identica_auth
self.conf.update(identica_auth[self.conf['USER'].lower()])
iclient = Client(webfinger=self.user,
type="native",
name="Gazouilleur",
key=self.conf['key'],
secret=self.conf['secret'])
self.conn = PyPump(client=iclient,
token=self.conf['token'],
secret=self.conf['token_secret'],
verifier_callback=lambda: "")
elif self.site == "twitter":
self.domain = "api.twitter.com"
self.user = self.conf['USER']
self.post = 'FORBID_POST' not in conf['TWITTER'] or str(
conf['TWITTER']['FORBID_POST']).lower() != "true"
args = {"api_version": self.twitter_api_version, "secure": True}
format = "json"
if get_token:
format = ""
args["api_version"] = None
args["auth"] = OAuth2(self.conf['KEY'], self.conf['SECRET'])
elif bearer_token:
args["auth"] = OAuth2(bearer_token=bearer_token)
else:
args["auth"] = OAuth(self.conf['OAUTH_TOKEN'],
self.conf['OAUTH_SECRET'],
self.conf['KEY'], self.conf['SECRET'])
if streaming:
self.domain = "stream.twitter.com"
args['block'] = False
args['timeout'] = 10
conn = TwitterStream
else:
if upload:
self.domain = "upload.twitter.com"
args['format'] = format
conn = Twitter
args['domain'] = self.domain
self.conn = conn(**args)
def __init__(self, api_keys):
self.oauth = OAuth(api_keys['OAUTH_TOKEN'], api_keys['OAUTH_SECRET'],
api_keys['KEY'], api_keys['SECRET'])
self.oauth2 = OAuth2(bearer_token=json.loads(
Twitter(api_version=None,
format="",
secure=True,
auth=OAuth2(api_keys['KEY'], api_keys['SECRET'])).oauth2.
token(grant_type="client_credentials"))['access_token'])
self.api = {
'user': Twitter(auth=self.oauth),
'app': Twitter(auth=self.oauth2)
}
self.waits = {}
self.auth = {}
def __init__(self, token, token_secret, consumer_key, consumer_secret,
listener=None, api_version='1.1'):
api_version = str(api_version)
if api_version not in ['1.1', '2']:
raise TypeError('API version can only be \'1.1\' or \'2\'.')
self.oauth = OAuth(
token,
token_secret,
consumer_key,
consumer_secret
)
bearer_token_client = Twitter(
api_version=None,
format='',
secure=True,
auth=OAuth2(consumer_key, consumer_secret)
)
bearer_token = json.loads(
bearer_token_client.oauth2.token(grant_type='client_credentials')
)['access_token']
self.oauth2 = OAuth2(bearer_token=bearer_token)
self.auth = {}
self.waits = {}
TwitterClass = Twitter
if api_version == '2':
TwitterClass = Twitter2
for route in APP_ONLY_ROUTES:
self.auth[route] = 'app'
self.waits[route] = {'app': 0}
self.endpoints = {
'user': TwitterClass(auth=self.oauth),
'app': TwitterClass(auth=self.oauth2)
}
self.listener = listener
def __setting_oauth2(self):
"""OAuth2のための設定を行う."""
api_key = os.environ['TWITTER_API_KEY']
api_secret = os.environ['TWITTER_API_SECRET']
return OAuth2(bearer_token=oauth2_dance(
api_key,
api_secret,
))
def create_app(config=None):
app = Flask("tweet_wall")
app.config['MONGODB_DB'] = os.getenv('TW_MONGODB_DB')
app.config['MONGODB_HOST'] = os.getenv('TW_MONGODB_HOST')
db.init_app(app)
app.jinja_env.filters[
'twitter_normal_to_bigger'] = twitter_normal_to_bigger
token = read_bearer_token_file(".oauth2_bearer_token")
twitter = Twitter(auth=OAuth2(bearer_token=token))
@app.route("/approved")
@app.route("/index")
@app.route("/")
def approved_tweets():
tweets = model.Tweet.objects(approved=True).order_by("-id_str").all()
return render_template('public.html', tweets=tweets)
@app.route("/approve", methods=["GET"])
@requires_auth
def approve_tweet_get():
hash_tag = _get_hash_tag_query_param()
tweets_twitter = twitter.search.tweets(q=hash_tag)["statuses"]
tweets_local = model.Tweet.objects(approved=True).all()
tweets_local_ids = [tweet.id_str for tweet in tweets_local]
tweets_not_approved = [
tweet for tweet in tweets_twitter
if tweet["id_str"] not in tweets_local_ids
]
return render_template('approve_tweets.html',
tweets=tweets_not_approved)
@app.route("/approve/<string:id_str>", methods=["POST"])
@requires_auth
def approve_tweet_post(id_str):
tweet = twitter.statuses.show(id=id_str)
tweet["approved"] = True
tweet.pop("id")
model.Tweet.objects(id_str=tweet["id_str"]).update_one(upsert=True,
**tweet)
return redirect(url_for('approve_tweet_get'))
@app.route("/twitter")
def tweets():
hash_tag = _get_hash_tag_query_param()
tweet_search = twitter.search.tweets(q=hash_tag)["statuses"]
return render_template('public.html', tweets=tweet_search)
return app
def onLoad(self):
if 'TwitterPoll' not in self.bot.dataStore:
self.bot.dataStore['TwitterPoll'] = {}
self.follows = self.bot.dataStore['TwitterPoll']
bearer_token = self._get_access_token()
self.twitter = tw(auth=OAuth2(bearer_token=bearer_token))
# start the thread that checks for new tweets
self.scanner = task.LoopingCall(self._scanLoop)
self._restartScanner()
def query_twitter(): current_token = TwitterAccessToken.objects.get(id = 7, active = 1) _TwitterOAuthToken = current_token.access_token _TwitterOAuthTokenSecret = current_token.access_token_secret _TwitterConsumerKey = current_token.api_key _TwitterConsumerSecret = current_token.api_secret TWITTER_ACCESS_DETAILS = (_TwitterConsumerKey, _TwitterConsumerSecret) twitterapi = Twitter(auth=OAuth2(bearer_token=oauth2_dance(*TWITTER_ACCESS_DETAILS))) # tweets = twitterapi.statuses.user_timeline(id = 348375714,count = 5,include_rts = True) tweets = twitterapi.search.tweets(q="#omgindia",geocode="20.593684,78.96288,500mi",count=100) for tweet in tweets["statuses"]: pp.pprint(tweet)
def connect_to_api(self): if len(self.twitterapps)>0: if self.appindex == len(self.twitterapps)-1: self.appindex = 0 # self.appindex = random.randint(0,len(self.twitterapps)-1) self.twapp = self.twitterapps[self.appindex] current_token = self.twitterapps[self.appindex] _TwitterOAuthToken = current_token.access_token _TwitterOAuthTokenSecret = current_token.access_token_secret _TwitterConsumerKey = current_token.api_key _TwitterConsumerSecret = current_token.api_secret TWITTER_ACCESS_DETAILS = (_TwitterConsumerKey, _TwitterConsumerSecret) twitterapi = Twitter(auth=OAuth2(bearer_token=oauth2_dance(*TWITTER_ACCESS_DETAILS))) # limit_status = twitterapi.application.rate_limit_status(resources="statuses,users") # pp.pprint(limit_status) # pp.pprint(TWITTER_ACCESS_DETAILS) self.appindex += 1 return twitterapi else: print "No Twitter Apps" return False
def main(event, context):
"""Query twitter for splatnet items and send a SMS if necessary."""
bearer_token = oauth2_dance(os.environ["TWITTER_KEY"],
os.environ["TWITTER_SECRET"])
twitter = Twitter(auth=OAuth2(bearer_token=bearer_token))
recent_tweet = twitter.statuses.user_timeline(screen_name="splatnetstore",
count=1)
tweet_content = recent_tweet[0]["text"]
# If desired we can use this to find specific manufacturers/abilities/items.
tweet_match = re.match("^(.+?)\\n(.+?)\\n(.+?)\\n(.+?)\\n(.+?)https",
tweet_content)
if "3" not in tweet_match.group(5):
return tweet_content
client = Client(os.environ["TWILIO_SID"], os.environ["TWILIO_SECRET"])
client.messages.create(
to=os.environ["RECIPIENT_NUMBER"],
from_=os.environ["TWILIO_NUMBER"],
body=tweet_content,
)
return True
if __name__ == '__main__':
try:
with open('config.json') as confile:
conf = json.loads(confile.read())
except Exception as e:
log('ERROR', 'Could not open config.json: %s %s' % (type(e), e))
sys.exit(1)
try:
oauth = OAuth(conf['twitter']['oauth_token'],
conf['twitter']['oauth_secret'], conf['twitter']['key'],
conf['twitter']['secret'])
oauth2 = OAuth2(bearer_token=json.loads(
Twitter(api_version=None,
format="",
secure=True,
auth=OAuth2(conf['twitter']['key'], conf['twitter']
['secret'])).oauth2.
token(grant_type="client_credentials"))['access_token'])
SearchConn = Twitter(domain="api.twitter.com",
api_version="1.1",
format="json",
auth=oauth2,
secure=True)
ResConn = Twitter(domain="api.twitter.com",
api_version="1.1",
format="json",
auth=oauth,
secure=True)
StreamConn = TwitterStream(domain="stream.twitter.com",
api_version="1.1",
##################################################################################
# Requires file keys.py to be in the same folder. Writes Twitter Bearer to keys,
# replacing the variable (variable must exist in file as program looks for word 'twitter_bearer' + anything after it (regex)
##################################################################################
# if accessing json file with values
# with open(path) as f:
# keys = json.load(f)
CONSUMER_KEY = keys.consumer_key #keys['consumer_key'] if keys is json file
CONSUMER_SECRET = keys.consumer_secret #keys['consumer_secret'] if keys is json file
twitter = Twitter(
auth=OAuth2(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET),
format="",
api_version="")
token = json.loads(twitter.oauth2.token(grant_type="client_credentials"))["access_token"]
# print(token)
def replace(file_path, pattern, subst):
#Create temp file
fh, abs_path = mkstemp()
with open(abs_path,'w') as new_file:
with open(file_path) as old_file:
for line in old_file:
new_file.write(sub(pattern, subst, line))
close(fh)
def __init__(self, consumer_key, consumer_secret):
bearer_token = oauth2_dance(consumer_key, consumer_secret)
self.client = Twitter(auth=OAuth2(bearer_token=bearer_token))
def init(config):
bt = config['twitter']['bearer-token']
tw.auth = OAuth2(bearer_token=bt)
def __init__(self, tweets_per_page=15, **search_params):
self.twitter = Twitter(auth=OAuth2(bearer_token=get_bearer_token()),
retry=100)
self.tweets_per_page = tweets_per_page
self.search_params = search_params
self.since_id = None
from app import application, api, daemon
from app.models import *
from app.utils import get_bearer_token, get_only_urls
from app import socket
# TODO clean this
try:
with open("config.py") as config_file:
exec(compile(config_file.read(), "config.py", 'exec'))
except:
pass
from twitter import Twitter, OAuth2
bearer_token = get_bearer_token(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET)
twitter = Twitter(auth=OAuth2(bearer_token=bearer_token))
class Resource(Resource):
method_decorators = [login_required]
@application.route('/')
def index():
if g.user is not None and g.user.is_authenticated:
return application.send_static_file('index.html')
# notifs = Notification.objects(user=session['user_id'])[:60]
# notifs_dicts = [notif.dump() for notif in notifs]
import json
from ratelimit import limits # type: ignore
from twitter import OAuth2, Twitter # type: ignore
BEARER_TOKEN = ""
twitter = Twitter(auth=OAuth2(bearer_token=BEARER_TOKEN))
global_tweet = []
FIFTEEN_MINUTES = 900
RECENT_SEARCH_CALL_CAP_FOR_FIFTEEN_MINUTES = 170
@limits(calls=RECENT_SEARCH_CALL_CAP_FOR_FIFTEEN_MINUTES,
period=FIFTEEN_MINUTES)
def search(params):
return twitter.search.tweets(**params)
def main():
search_word = "bigquery"
immutable_params = {
"q": search_word,
"count": 100,
}
params = {
"q": search_word,
"count": 100,
}
def parseToParam(parse_str, parse=None):
from twitter import Twitter, OAuth2
import spacy
import json
import os
from dotenv import load_dotenv
# load global data
load_dotenv()
model_dir = './models'
nlp = spacy.load(model_dir)
SCORE_THRESHOLD = 5
TWEET_COUNT = 50
# establish connection to Twitter
twitter = Twitter(auth=OAuth2(
bearer_token=os.environ.get('TWITTER_ACCESS_TOKEN')))
print('Connected to Twitter.')
def get_situations(request):
request_args = request.args
if request_args and 'q' in request_args:
query = request_args['q']
else:
query = ""
twitter_response = twitter_query(query, 'en')
result = parse_twitter_response(twitter_response)
return json.dumps(result)
#/usr/bin/env python
# -*- coding: utf-8 -*-
import csv, json
from time import time, sleep
from pymongo import MongoClient
from twitter import Twitter, OAuth2, TwitterHTTPError
from config import CSV_SOURCE, CSV_ENCODING, CSV_TWITTER_FIELD, MONGO_DATABASE, TWITTER
from gazouilloire.tweets import prepare_tweet
with open(CSV_SOURCE) as f:
data = list(csv.DictReader(f, delimiter=';'))
oauth2 = OAuth2(bearer_token=json.loads(
Twitter(api_version=None,
format="",
secure=True,
auth=OAuth2(TWITTER['KEY'], TWITTER['SECRET'])).oauth2.token(
grant_type="client_credentials"))['access_token'])
api = Twitter(auth=oauth2)
db = MongoClient("localhost", 27017)[MONGO_DATABASE]
def wrapper(route, args={}, tryouts=50):
try:
return route(**args)
except TwitterHTTPError as e:
routestr = '/'.join(route.uriparts[1:])
if e.e.code == 429:
reset = int(e.e.headers["x-rate-limit-reset"])
sleeptime = int(reset - time() + 2)
