def main():
#the initial ratios can be adapted to normal mood so you dont receive alert
#while starting the code, but otherwise is useful for testing email and flashing.
c = AnimodelMundo(0.6,0.05,2.5,4,[0.18,0.18,0.35,0.04,0.06, 0.04,0.11],'None')
msg_dict = {}
t = twitter_login.login()
#led will not flash unless something big happens
while True:
flash = False
#rellenando todos los tps
for animoID in range(NUM_TIPOS_ANIMO):
tps,msg_dict[animoID] = parse_tps(animoID,c,t)
#trabajemos con tweets por minuto
tpm = tps * 60
c.registrar_tweets(animoID,tpm)
c.calcula_animo_actual()
intensity = c.calcula_intensidad_animo_actual()
register_plot(c.all_tpm,c.ratios_animo_mundial,c.ratios_temperamento)
#actually ploting chart
retcode = subprocess.call(["gnuplot", "./plots/animo.dat"])
print 'returning code for ploting is= '+str(retcode)
print "la intensidad actual es= "+str(intensity)
write_to_html(intensity,c.ANIMO_MUNDIAL)
if (intensity == IntensidadAnimo.EXTREMO or intensity == IntensidadAnimo.CONSIDERABLE):
#taking tweets from right emotion to send
msg_email = msg_dict[c.ANIMO_MUNDIAL]
print "sending mail and flashing"
#send_mail(msg_email,c.ANIMO_MUNDIAL)
flash = True
register_alert(msg_email,c.ANIMO_MUNDIAL)
print 'timestamp: '+str(_time.time())+' setting colorid '+str(c.ANIMO_MUNDIAL)
setserial(c.ANIMO_MUNDIAL,flash)
_time.sleep(60)
return 0
def summary(screen_name, r):
t = login()
#some wrapper around _getFriendsOrFollowersUsingFunc
#that bind the first two arguments
getFriendIds = functools.partial(tu._getFriendsOrFollowersUsingFunc,
t.friends.ids,
'friend_ids',
t,
r)
getFollowerIds = functools.partial(tu._getFriendsOrFollowersUsingFunc,
t.followers.ids,
'follower_ids',
t,
r)
#get the data
getFriendIds(screen_name, limit=sys.maxint)
getFollowerIds(screen_name, limit=sys.maxint)
#using Redis to compute the numbers
n_friends = r.scard(tu.getRedisIdByScreenName(screen_name, 'friend_ids'))
n_followers = r.scard(tu.getRedisIdByScreenName(screen_name,
'follower_ids'))
n_friends_diff_followers = r.sdiffstore(
'temp', [tu.getRedisIdByScreenName(screen_name,
'friend_ids'),
tu.getRedisIdByScreenName(screen_name,
'follower_ids')])
r.delete('temp')
n_followers_diff_friends = r.sdiffstore(
'temp',
[tu.getRedisIdByScreenName(screen_name,
'follower_ids'),
tu.getRedisIdByScreenName(screen_name,
'friend_ids')])
r.delete('temp')
n_friends_inter_followers = r.sinterstore(
'temp',
[tu.getRedisIdByScreenName(screen_name,
'follower_id'),
tu.getRedisIdByScreenName(screen_name,
'friend_id')])
r.delete('temp')
print '%s is following %s' % (screen_name, n_friends)
print '%s is being followerd by %s' % \
(screen_name, n_followers)
print '%s of %s is not following back' % \
(n_friends_diff_followers, n_friends)
print '%s of %s is not following back by %s' % \
(n_followers_diff_friends, n_followers, screen_name)
print '%s has %s mutual friends ' % \
(screen_name, n_friends_inter_followers)
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--name', type=str, help='the screen name')
ap.add_argument('--id', type=str, help='the user id')
args = ap.parse_args()
t = login()
print getFriendIds(t, args.name, args.id)
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--name', type=str, help='the screen name')
ap.add_argument('--id', type=str, help='the user id')
args = ap.parse_args()
t = login()
print getFriendIds(t, args.name, args.id)
def main():
t = login()
r = redis.Redis()
args = get_args()
assert args.start_node, "Input a start node name(screen name)"
assert args.depth, "Input a depth to exploit"
users = exploit_network(t, r, args.start_node, args.depth)
print "There are %d of users in the network of %s in depth %d" % (len(users), args.start_node, args.depth)
r.save()
def main():
t = login()
r = redis.Redis()
args = get_args()
assert args.start_node, 'Input a start node name(screen name)'
assert args.depth, 'Input a depth to exploit'
users = exploit_network(t, r, args.start_node, args.depth)
print "There are %d of users in the network of %s in depth %d" \
% (len(users), args.start_node, args.depth)
r.save()
def handle(self, *args, **options):
# Get the configuration parameters
c = config.Config()
d = c.cfg
# Load the classifier
f = open('bayesclass.pickle')
classifier = pickle.load(f)
t = login()
KW = {'user' : d.get('api', 'user'),
'count' : d.get('api', 'count'),
'skip_users' : d.get('api', 'skip_users'),
'include_entities' : 'true',
'since_id' : 1,
'id' : 2}
p = Tweet.objects.aggregate(Max('tweet_id'))
latestId = p['tweet_id__max']
if latestId == None:
latestId = 1
KW['since_id'] = int(latestId)
api_call = getattr(t.statuses, 'user_timeline')
tweets = makeTwitterRequest(t, api_call, **KW)
print 'Fetched %i tweets' % len(tweets)
a = len(tweets)
for i in range(a):
txt = tweets[i]['text']
ref = tweets[i]['id']
src = tweets[i]['source']
outc = int(classifier.classify(word_feats(txt)))
created = mysql_date(tweets[i]['created_at'])
q = Tweet( datetime = created,
user = K['user'],
content = txt,
source = src,
tweet_id = ref,
prop = outc )
q.save()
f.close()
def filter_market_tweet():
t = login()
r = redis.Redis()
#load company rules
rule_file = "/home/vic/work/twitter_finance/dictionary/company_rule.txt"
stock_rule = json.load(open(rule_file))
for index in stock_rule:
country = get_country_by_index(index)
ks = []
ks.extend(stock_rule[index]["index"])
for company, rs in stock_rule[index]["company"].items():
rule = rs[0].replace("*", "")
if len(rule) >= 4:
ks.append(rule)
for keyword in ks:
search_tweets(t, r, keyword, country)
r.save()
def summary(screen_name, r):
t = login()
# some wrapper around _getFriendsOrFollowersUsingFunc
# that bind the first two arguments
getFriendIds = functools.partial(tu._getFriendsOrFollowersUsingFunc, t.friends.ids, "friend_ids", t, r)
getFollowerIds = functools.partial(tu._getFriendsOrFollowersUsingFunc, t.followers.ids, "follower_ids", t, r)
# get the data
getFriendIds(screen_name, limit=sys.maxint)
getFollowerIds(screen_name, limit=sys.maxint)
# using Redis to compute the numbers
n_friends = r.scard(tu.getRedisIdByScreenName(screen_name, "friend_ids"))
n_followers = r.scard(tu.getRedisIdByScreenName(screen_name, "follower_ids"))
n_friends_diff_followers = r.sdiffstore(
"temp",
[tu.getRedisIdByScreenName(screen_name, "friend_ids"), tu.getRedisIdByScreenName(screen_name, "follower_ids")],
)
r.delete("temp")
n_followers_diff_friends = r.sdiffstore(
"temp",
[tu.getRedisIdByScreenName(screen_name, "follower_ids"), tu.getRedisIdByScreenName(screen_name, "friend_ids")],
)
r.delete("temp")
n_friends_inter_followers = r.sinterstore(
"temp",
[tu.getRedisIdByScreenName(screen_name, "follower_id"), tu.getRedisIdByScreenName(screen_name, "friend_id")],
)
r.delete("temp")
print "%s is following %s" % (screen_name, n_friends)
print "%s is being followerd by %s" % (screen_name, n_followers)
print "%s of %s is not following back" % (n_friends_diff_followers, n_friends)
print "%s of %s is not following back by %s" % (n_followers_diff_friends, n_followers, screen_name)
print "%s has %s mutual friends " % (screen_name, n_friends_inter_followers)
def main():
t = login()
r = redis.Redis()
keywordfile = sys.argv[1]
outfile = sys.argv[2]
with codecs.open(keywordfile, 'r') as kf:
keyword_list = [k.replace("\n", "") for k in kf.readlines()]
country_words = []
#construct country combination of the keywords and country
for country in COUNTRY:
for word in keyword_list:
country_words.append("%s %s" % (country, word))
out_file = codecs.open(outfile, "a")
for keyword in country_words:
result = search_tweets(t, r, keyword)
for res in result:
out_file.write(
json.dumps(res,
ensure_ascii=False).encode('utf8') + "\n")
out_file.flush()
out_file.flush()
out_file.close()
r.save()
return locale.format('%d', _int, True)
def getRedisIdByScreenName(screen_name, key_name):
return 'screen_name$' + screen_name + '$' + key_name
def getRedisIdByUserId(user_id, key_name):
return 'user_id$' + str(user_id) + '$' + key_name
# For calculating the max_id parameter from statuses, which is
# necessary in order to traverse a timeline in the v1.1 API.
# See https://dev.twitter.com/docs/working-with-timelines
def getNextQueryMaxIdParam(statuses):
return min([ status['id'] for status in statuses ]) - 1
if __name__ == '__main__': # For ad-hoc testing
t = login()
# Test the flow for hitting the rate limit and pausing until
# it's time to make another request on an arbitrary resource.
# See https://dev.twitter.com/docs/rate-limiting/1.1/limits
while True:
resp = makeTwitterRequest(t.help.languages)
print resp
print resp.headers.items()
print
def connect():
return twitter_login.login()
#!/usr/bin/python
# -*- coding: utf-8 -*-
__author__ = "Wei Wang"
__email__ = "*****@*****.**"
import sys
from twitter_login import login
import redis
import functools
from twitter_util import getUserInfo
from twitter_util import _getFriendsOrFollowersUsingFunc
SCREEN_NAME = sys.argv[1]
DEPTH = sys.argv[2]
t = login()
r = redis.Redis()
getFriends = functools.partial(_getFriendsOrFollowersUsingFunc, t.friends.ids,
'friend_ids', t, r)
getFollowers = functools.partial(_getFriendsOrFollowersUsingFunc,
t.followers.ids, 'follower_ids', t, r)
def crawl(
screen_names,
friends_limit=10000,
followers_limit=10000,
depth=1,
friends_sample=.2,
def connect(): return twitter_login.login()
