#!/usr/bin/env python
# http://oscon.com/oscon2012/public/schedule/detail/24416
# twy_a.py (by Wesley Chun under Apache2 license)
# http://www.apache.org/licenses/LICENSE-2.0.html
from distutils.log import warn as printf
try:
import twython
except ImportError:
import twython3k as twython
import settings
printf('\n*** Get user status (authorization required)')
twitter = twython.Twython(
twitter_token=settings.CONSUMER_KEY,
twitter_secret=settings.CONSUMER_SECRET,
oauth_token=settings.ACCESS_TOKEN,
oauth_token_secret=settings.ACCESS_TOKEN_SECRET,
)
data = twitter.verifyCredentials()
status = data['status']
printf('''
User: @%s
Date: %s
Tweet: %s''' % (data['screen_name'], status['created_at'], status['text']))
import twython as T, maccess, time, pickle
import multiprocessing as mp
terms = [
"#jesus", "#g1", "#prayforthephilippines", "#felipao", "#ReadyForScorch",
"#obama", "#dilma", "#science", "#god"
]
fnames = [
"pickleDir/{}".format(term.replace("#", "HASH") + ".pickle")
for term in terms
]
twitters = []
searchs = []
for tw, term in zip(maccess.TW, terms):
twitter = T.Twython(app_key=tw.tak,
app_secret=tw.taks,
oauth_token=tw.tat,
oauth_token_secret=tw.tats)
search = twitter.cursor(twitter.search, q=term)
#search = twitter.search_gen(term)
twitters.append(twitter)
searchs.append(search)
def rodaSearch(search, fname, output, rr=None):
if not rr:
rr = []
for result in zip(list(range(2500)), search):
print("result " + fname)
rr.append(result)
f = open(fname, "wb")
rrr = rr[:]
import webapp2
import time
import sys
import random
import twython
from twython import Twython, TwythonError
from google.appengine.ext import db
CONSUMER_KEY = ‘???’
CONSUMER_SECRET = ‘???’
ACCESS_KEY = ‘???’
ACCESS_SECRET = ‘???’
from datetime import *
today = date.today()
future = date(2018,11,5)
diff = future - today
NUMBER = diff.days
twitter = twython.Twython(
CONSUMER_KEY,
CONSUMER_SECRET,
ACCESS_KEY,
ACCESS_SECRET
)
photo = open("%s.jpg" %NUMBER,'rb')
response = twitter.upload_media(media=photo)
twitter.update_status(status="%s days until the United States Midterm Elections on November 6th, 2018. #election2018 #campaign2018 #politics" %NUMBER, media_ids=[response['media_id']])
#!/usr/bin/python
# coding: utf-8
import os
import twython
import urllib3.contrib.pyopenssl
#urllib3.contrib.pyopenssl.inject_into_urllib3()
api = twython.Twython(os.getenv("CONSUMER_KEY"),
os.getenv("CONSUMER_SECRET"),
os.getenv("ACCESS_KEY"),
os.getenv("ACCESS_SECRET"))
def tweet(s):
try:
api.update_status(status = s)
except twython.TwythonError as e:
print e
if __name__ == '__main__':
tweet("test message 1")
import twython
import sys
import subprocess
app_key = "XXX"
app_secret = "XXX"
oauth_token = "XXX"
oauth_token_secret = "XXX"
client_args = {'verify': False}
twitter = twython.Twython(app_key,
app_secret,
oauth_token,
oauth_token_secret,
client_args=client_args)
twitter.verify_credentials()
pic = sys.argv[1]
print(pic)
try:
f = open(pic, 'rb')
except IOError:
print "Error: can't find or open file"
else:
# Tweeting picture
twitter.update_status_with_media(
status="jarvis detected motion in workspace2", media=f)
subprocess.call(["mplayer", "/home/jarvis/alarm/audio/pic_posted.m4a"])
def __init__(self) -> None:
"""Initialise the Twython object"""
self.twitter = twython.Twython(APP_KEY, APP_SECRET)
self.ids = self.get_tweet_ids()
self.ids_seen = []
def __init__(self, credentials):
self.twitter = twython.Twython(*credentials)
import os, time
import cPickle as pickle
import twython as Twython
from urllib import quote
from SETTINGS import *
api = Twython.Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
latest_tweet_id = 0
def first_run():
file_exists = os.path.exists('sav.p')
if file_exists is False:
user_timeline = api.get_user_timeline(screen_name=user_name, count=2)#This 'count' is how many tweets back from the most recent tweet that will be fowarded to telegram
tweet_id = user_timeline[1]['id']
file_pickle(tweet_id)
def get_timeline(latest_tweet_id):
user_timeline = api.get_user_timeline(screen_name=user_name, since_id=latest_tweet_id)
return user_timeline
def read_latest_id():
line = file_unpickle()
if len(str(line)) < 2:
return 0
else:
return line
def send_message(msg):
msg = quote(msg, safe='')
link = 'https://api.telegram.org/bot'+telegram_token+'/sendMessage?chat_id=@'+channel_name+'\&text="' + msg + '"'
os.system('curl '+ link)
def file_pickle(var):
pickle.dump(var, open("sav.p", "wb"))
humid_str = str("{0:.1f}".format(gsd.sensor_data['humidity']))
pressure_str = str("{0:.1f}".format(gsd.sensor_data['pressure']))
config_file = ConfigParser.SafeConfigParser()
config_file_path = path.dirname(
path.abspath(__file__)) + "/.twitter_config"
config_file.read(config_file_path)
consumerKey = config_file.get("settings", "consumerKey")
consumerSecret = config_file.get("settings", "consumerSecret")
accessToken = config_file.get("settings", "accessToken")
accessSecret = config_file.get("settings", "accessSecret")
replyTarget = config_file.get("settings", "replyTarget")
api = twython.Twython(app_key=consumerKey,
app_secret=consumerSecret,
oauth_token=accessToken,
oauth_token_secret=accessSecret)
tweet_str = "@" + replyTarget + " 現在の温度は" + temp_str + "度 湿度は" + humid_str + "％ 気圧は" + pressure_str + "hPa です" + '\r\n'
if gsd.sensor_data['temp'] > 25:
tweet_str += "暑いですね" + '\r\n'
if gsd.sensor_data['temp'] < 10:
tweet_str += "寒いですね" + '\r\n'
if gsd.sensor_data['humidity'] > 60:
tweet_str += "むしむししますね" + '\r\n'
try:
api.update_status(status=tweet_str)
except twython.TwythonError as e:
from geopy import Nominatim
import requests
import twython as tw
from motionless import DecoratedMap, LatLonMarker
WHITE_PAGES_API_KEY = 'ea04b1f16b56a1b1a21b0159b8b1990e'
TWITTER_KEY = 'YABlxDeSUvuJGLcJoGsuFpCvA'
TWITTER_SECRET = 'ALttKP1BNhsRqvGL2PR9mkcGwdgh3gKs05v8pfjJrLElrxjQ8L'
TWITTER_TOKEN = '4840597894-HxW7lZoZQIbmkEHTjfaeb9wCDVZyLNPxAvczMZr'
TWITTER_TOKEN_SECRET = 'ULfOa5W84nJCj5mEvULVqtmTDFWI2x8ooqgvzNonVqhIR'
SEARCH_RADIUS = '100' # tweet search radius
SEARCH_UNITS = 'mi'
TWITTER = tw.Twython(TWITTER_KEY, TWITTER_SECRET, TWITTER_TOKEN,
TWITTER_TOKEN_SECRET)
def query_white_pages(phone_number):
'''
Returns the address of an input phone number
'''
req = 'https://proapi.whitepages.com/2.1/phone.json?api_key=%s&phone_number=%s' % (
WHITE_PAGES_API_KEY, phone_number)
result = requests.get(req)
asDict = json.loads(result.text)
locationValues = asDict['results'][0]['best_location']
locKeys = [
def __init__(self, consumer_key, consumer_secret,
access_token_key, access_token_secret):
self.twitter = twython.Twython(consumer_key, consumer_secret,
access_token_key, access_token_secret)
import tweetlib
import sys
import os
import twython
import random
import sys
api = twython.Twython();
try:
tweeterfile_loc = sys.argv[1];
feedslib = sys.argv[2];
except:
tweeterfile_loc = 'C:\\Users\\Stoop\\Desktop\\Scriptie\\tweetdata\\twitteraars.txt';
feedslib = 'C:\\Users\\Stoop\\Desktop\\Scriptie\\tweetdata\\feeds\\';
#Get all tweeters, and shuffle them (so we don't always start with the same)
tweeterfile = open(tweeterfile_loc,'r');
tweeters = [];
for tweeter in tweeterfile:
tweeters.append(tweeter[:-1]);
random.shuffle(tweeters);
#See if they have tweets we don't have (yet)
for tweeter in tweeters[:25]:
if tweeter == '':
continue;
import os
import twython
import nltk
import midiutil
APP_KEY = os.environ['APP_KEY']
APP_SECRET = os.environ['APP_SECRET']
authentication = twython.Twython(APP_KEY, APP_SECRET, oauth_version=2)
ACCESS_TOKEN = authentication.obtain_access_token()
twitter = twython.Twython(APP_KEY, access_token=ACCESS_TOKEN)
def get_pos(text):
tokens = nltk.word_tokenize(text)
tagged_tokens = nltk.pos_tag(tokens)
return tagged_tokens
def clean_tweet(pos):
cleaned = []
is_username = False
for tag in pos:
print tag
#eliminate emojis and punctuation
if '\u' not in tag[0].encode('unicode-escape') and '\U' not in tag[
0].encode('unicode-escape') and '.' not in tag[
1] and ',' not in tag[1] and ':' not in tag[1]:
if '@' in tag[0]:
#don't add the @ symbol on its own, add it to the username
is_username = True
else:
import os, time
try:
import cPickle as pickle
except:
import pickle
import twython as Twython
from urllib import quote
from src import setting as st
api = Twython.Twython(st.APP_KEY, st.APP_SECRET, st.OAUTH_TOKEN, st.OAUTH_TOKEN_SECRET)
latest_tweet_id = 0
def first_run():
file_exists = os.path.exists('sav.p')
if file_exists is False:
user_timeline = api.get_user_timeline(screen_name=st.user_name,
count=2) # This 'count' is how many tweets back from the most recent tweet that will be fowarded to telegram
tweet_id = user_timeline[1]['id']
file_pickle(tweet_id)
def get_timeline(latest_tweet_id):
user_timeline = api.get_user_timeline(screen_name=st.user_name, since_id=latest_tweet_id)
return user_timeline
def read_latest_id():
line = file_unpickle()
import os
import time
# Set working directory
os.chdir('/path/to/your/directory/') # I set my parent directory to a folder containing subfolders for data, figures, and scripts
# Get OAuth credentials. Need to copy the access token and access token secret as well. Run this code each time you are using twitteR.
APP_KEY = 'aWZoLAPZ5aSgImEwvnKG4In1l'
APP_SECRET = 'TWXKRftQs9q5UFkJwrIOJA7muEBLL7L2HATJoZ0V8ANDMZmhBM'
OAUTH_TOKEN = '24574024-xETTs1DL50vFGJbztRlg79s4EMmzlEKIrDgx5q8bz'
OAUTH_TOKEN_SECRET = 'h38UP5vQpktpyiEOv7GBaObdR43zh1lcAvkI4O4WWwo4Y'
# Connect
connection = twy.Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
# How many tweets to return per query
size = 100 # Modify as needed, maximum is 100
# One word
nba_tweets = connection.search(q='nba', count=size) # Also returns hashtags, and Twitter is not case sensitive.
nba_tweets2 = connection.search(q='nba', count=size) # Search queries launched almost simultaneously return different results.
# Mentions
obama = connection.search(q='@BarackObama', count=size)
# Multiple words
nba_tweets3 = connection.search(q='nba OR nra', count=size)
def get_twython_instance(api):
""" Initialize an instance of Twython with variables needed """
logger.info("Connecting to Twitter API...")
return twython.Twython(api['CONSUMER_KEY'], api['CONSUMER_SECRET'],
api['ACCESS_TOKEN'], api['ACCESS_TOKEN_SECRET'])
def setup_twitter(self):
credentials = json.load(open('credentials.json'))
self.twitter = twython.Twython(credentials["api_key"],
credentials["api_secret"],
credentials["access_token"],
credentials["token_secret"])
import random
import sys
import twython
from generate import generate, get_subj_from_wikilink
consumer_key, consumer_secret, access_token, token_secret = sys.argv[1:]
twitter = twython.Twython(consumer_key, consumer_secret, access_token,
token_secret)
pool = [s.strip() for s in open("pool.txt").readlines()]
if random.randrange(8) > 0:
subj = get_subj_from_wikilink(
'http://en.wikipedia.org' + random.choice(pool))
status = generate(subj)
else:
status = generate()
twitter.update_status(status=status)
def twitter_api(token, token_secret, consumer_key, consumer_secret):
return twython.Twython(app_key=consumer_key,
app_secret=consumer_secret,
oauth_token=token,
oauth_token_secret=token_secret)
'twitter', 'Response: 200 OK'))
datadog_thread.daemon = True
datadog_thread.start()
tweets_read_file = os.path.join(bot.config_path, "Tweets Read.txt")
if not os.path.isfile(tweets_read_file):
bot.log.info("Creating: {}".format(tweets_read_file))
with open(tweets_read_file, 'w') as file:
file.write('')
tweets_read = []
else:
with open(tweets_read_file, 'r') as file:
tweets_read = file.read().splitlines()
api = twython.Twython(twitter_keys['consumer_key'],
twitter_keys['consumer_secret'],
twitter_keys['access_token'],
twitter_keys['access_token_secret'])
bot.api = api
read_notifications()
bot.log.info("Reading Twitter Stream.")
stream = TwitterStream(twitter_keys['consumer_key'],
twitter_keys['consumer_secret'],
twitter_keys['access_token'],
twitter_keys['access_token_secret'],
timeout=120,
retry_count=3,
retry_in=10)
stream.statuses.filter(
track=', '.join([x.lower() for x in bot.settings['twitter_track']]))
#!/usr/bin/env python
# http://oscon.com/oscon2012/public/schedule/detail/24416
# twy_u.py (by Wesley Chun under CC-SA3.0 license)
from distutils.log import warn as printf
try:
import twython
except ImportError:
import twython3k as twython
TMPL = '''
User: @%(from_user)s
Date: %(created_at)s
Tweet: %(text)s'''
printf('\n*** Search for "python" (authorization NOT required)')
twitter = twython.Twython()
data = twitter.search(q='python')
for tweet in data['results']:
printf(TMPL % tweet)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import twython, time, sys, json, datetime, argparse
aparser = argparse.ArgumentParser(description='Retrieve media tweets as list of IDs')
aparser.add_argument('-n', '--nb', help='Number of tweets to retrieve', default=50000)
aparser.add_argument('-o', '--outfile', help='Output file', required=True)
args = aparser.parse_args()
# Connect to Twitter
from config import *
twitter = twython.Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
#twitter.verify_credentials()
# Query
query = '(#Euro2016 AND since:2016-06-10 AND lang:fr'
# Open output file
outfile = open(args.outfile, 'w')
# Loop to retrieve tweets
nb = 0
nbMax = int(args.nb)
maxid = None
excludeRetweets = False
while nb < nbMax:
print '--- Retrieved:', nb, '(maxid: ', str(maxid), ')'
try:
tweets = []
print '--- Searching'
# Given a hashtag, get all the tweets, stuff them in a json.
import argparse, csv, collections, json, twython, ConfigParser, time
parser = argparse.ArgumentParser()
parser.add_argument('--config_file', default='config.txt')
parser.add_argument('--hashtag', default='chi2016')
parser.add_argument('--outfile')
args = parser.parse_args()
config = ConfigParser.ConfigParser()
config.read(args.config_file)
# Man, I thought the runaround was easier than this.
twitter = twython.Twython(config.get('twitter', 'app_key'),
config.get('twitter', 'app_secret'),
oauth_version=2)
ACCESS_TOKEN = twitter.obtain_access_token()
twitter = twython.Twython(config.get('twitter', 'app_key'),
access_token=ACCESS_TOKEN,
oauth_version=2)
if not args.hashtag.startswith('#'):
args.hashtag = '#' + args.hashtag
statuses = []
max_id = None
for i in range(10): # retrieve max 10 * 100 tweets
if not max_id:
results = twitter.search(q=args.hashtag, count=100)
def main(unused):
twitter = twython.Twython(CONSUMER_KEY, CONSUMER_SECRET, OAUTH_TOKEN,
OAUTH_TOKEN_SECRET)
if not twitter:
logging.fatal('Invalid twitter credentials!')
if not FLAGS.input_tweet_ids_file:
logging.fatal('Must specify --input_tweet_ids_file!')
if not FLAGS.output_tweets_directory:
logging.fatal('Must specify --output_tweets_directory!')
if not os.path.isdir(FLAGS.output_tweets_directory):
os.makedirs(FLAGS.output_tweets_directory)
# Prevents us from sending too many requests to Twitter too quickly.
limiter = ratelimiter.RateLimiter(max_calls=FLAGS.rate_limit, period=1.5)
# Fetches a single Tweet at a time.
def GetTweet(id):
with limiter:
return twitter.show_status(id=id)
# Fetches up to 100 Tweets at a time.
def GetTweets(ids):
if len(ids) > 100:
logging.fatal('Max 100 ids per batch lookup')
combined_ids = ','.join(ids)
with limiter:
return twitter.lookup_status(id=combined_ids)
# Maps tweet id to the actual data of the tweet (text, timestamp, etc).
tweet_id_to_tweet_data = dict()
# Maps tweet id to which file the actual data is in.
tweet_id_to_tweet_data_filename = dict()
tweet_mapping_filename = os.path.join(FLAGS.output_tweets_directory,
'tweet_mapping.json')
if os.path.exists(tweet_mapping_filename):
with open(tweet_mapping_filename, 'r') as tweet_mapping_file:
tweet_id_to_tweet_data_filename = json.load(tweet_mapping_file)
with open(FLAGS.input_tweet_ids_file, 'r') as input_tweet_ids_file:
tweet_ids_to_fetch = []
for tweet_id in input_tweet_ids_file:
tweet_id = tweet_id.strip()
# Already fetched this Tweet before, don't do it again.
if tweet_id in tweet_id_to_tweet_data_filename:
logging.info('Skipping fetch tweet ' + tweet_id)
continue
# Add this Tweet to the batch of Tweets to lookup next.
tweet_ids_to_fetch.append(tweet_id)
# Lookup in batches of 100
if len(tweet_ids_to_fetch) < 100:
continue
logging.info('Fetching batch of tweets...')
while True:
try:
tweet_datas = GetTweets(tweet_ids_to_fetch)
for tweet_data in tweet_datas:
tweet_id = tweet_data['id_str']
tweet_id_to_tweet_data[tweet_id] = tweet_data
# Mark that we've already tried to fetch failures.
for tweet_id_to_fetch in tweet_ids_to_fetch:
if tweet_id_to_fetch not in tweet_id_to_tweet_data:
tweet_id_to_tweet_data[tweet_id_to_fetch] = {}
tweet_ids_to_fetch = []
break
except twython.TwythonRateLimitError as err:
logging.info(str(err) + ' ... trying again')
continue
except twython.TwythonError as err:
logging.fatal(err)
# Dump the Tweets to a file in batches.
if len(tweet_id_to_tweet_data) >= FLAGS.output_tweets_file_size:
tweet_data_basename = GetNextBasename(
FLAGS.output_tweets_directory)
tweet_data_filename = os.path.join(
FLAGS.output_tweets_directory, tweet_data_basename)
with open(tweet_data_filename, 'w') as tweet_data_file:
json.dump(tweet_id_to_tweet_data, tweet_data_file)
for tweet_id in tweet_id_to_tweet_data:
tweet_id_to_tweet_data_filename[
tweet_id] = tweet_data_basename
with open(tweet_mapping_filename, 'w') as tweet_mapping_file:
json.dump(tweet_id_to_tweet_data_filename,
tweet_mapping_file)
tweet_id_to_tweet_data = dict()
from urllib2 import urlopen
from bs4 import BeautifulSoup
import requests
# GET TWEET
with open("twitter_keys.txt") as f:
content = f.readlines()
# Twitter API keys go here
CONSUMER_KEY = content[0].rstrip()
CONSUMER_SECRET = content[1].rstrip()
OAUTH_TOKEN = content[2].rstrip()
OAUTH_TOKEN_SECRET = content[3].rstrip()
twitter = twython.Twython(CONSUMER_KEY, CONSUMER_SECRET, OAUTH_TOKEN,
OAUTH_TOKEN_SECRET)
response = twitter.search(
q=
'#firstworldproblems AND [worst OR ruined OR dying OR worse OR hate OR annoying OR pissed OR annoyed OR panic OR suffering OR distraught OR bitch OR damn OR f*****g OR f****d OR hell OR starving OR stupid OR forever]',
result_type='recent',
lang='en',
count=1)
first_tweet = response['statuses'][0]
first_world_tweet = first_tweet.get('text')
target = first_tweet['user']['screen_name']
targetID = first_tweet['id_str']
## use naive bayes classifier to classify the tweet
csvFile = pd.read_csv("Training_test/training.csv",
