from lib.users import Users
import json
from boto import kinesis
aws_region = "us-west-2"
user = "******"
password = "******"
interval = 1500
count = 100
stream_name = "TestStream"
u = Users(user, password, interval, count)
x = u.list()
for line in x.iter_lines():
kinesis = kinesis.connect_to_region(aws_region)
kinesis.put_record(stream_name, line, "partitionkey")
if line:
print(line)
from lib.users import Users
from lib.utils import response_builder, logger
from botocore.exceptions import ClientError
users = Users()
def handler(event, context):
try:
logger.info(event)
user_id = event['pathParameters']['user_id']
users.delete(user_id=user_id)
except ClientError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(204)
inferred_location = Util.str_to_tuple(inferred_city)
user['location_point'] = inferred_location
def get_users(self):
return self.users
if __name__ == '__main__':
import sys
from lib.db import DB
from lib.users import Users
from lib.tweets_db import Tweets
from lib.words import Words
if len(sys.argv) < 5:
print '[usage]: python %s [users file path] [db user name] [db pass] [db name]' % sys.argv[0]
exit()
users = Users()
users.load_file(sys.argv[1])
db = DB(sys.argv[2], sys.argv[3], sys.argv[4])
tweets = Tweets(db)
lwords = Words()
ch = Cheng(users, tweets, lwords)
#print tl.extract_local_words({'dmin':0.05, 'cmin':30})
#print tl.extract_local_words_(tl.tweets.stream(), {'dmin':0.05, 'cmin':30, 'window_size':1800, 'tl':False, 'default':False, 'divergence':'l2'})
print ch.extract_local_words_batch({'dmax':400000, 'cmin':30, 'lang': 'en'})
#print tl.extract_local_words_batch({'dmin':1.0, 'cmin':30, 'window_size':1800, 'tl':False, 'default':False, 'divergence':'kl'})
#print tl.extract_local_words_batch({'dmin':300000, 'cmin':30, 'window_size':1800, 'tl':False, 'default':False, 'divergence':'dispersion'})
f = open(filepath, 'r')
params = json.loads(f.read().rstrip())
f.close()
return params
def evaluate(inferred, answer):
for u in answer.iter():
v = inferred.get(u['id'])
if v['location'] != None:
print Util.hubeny_distance(v['location'], u['location'])
if len(sys.argv) < 8:
print '[usage]: python %s [training set] [test set] [params] [db user name] [db pass] [db name] [model file]' % sys.argv[0]
exit()
training = Users()
training.load_file(sys.argv[1])
test = Users()
test.load_file(sys.argv[2])
params = load_params(sys.argv[3])
db = DB(sys.argv[4], sys.argv[5], sys.argv[6])
tweets = Tweets(db)
olim = OLIM(training, tweets, params)
""" quadtree partitioning """
if os.path.exists(sys.argv[7]):
f = open(sys.argv[7])
qtree = pickle.load(f)
def test_user_permissions(login_as_admin):
LOG.info("test_user_permissions")
# Create new user and assign "user" role
new_username = "******"
new_password = "******"
new_user_roles = "user"
response = Users().create_user(APP_URL, login_as_admin, new_username,
new_password)
assert response.ok
response_data = response.json()
new_user_id = response_data["id"]
assert response_data["username"] == new_username
assert response_data["roles"] == "user"
# Login as the newly created user
response = Auth().login(APP_URL, new_username, new_password)
assert response.ok
response_data = response.json()
access_token = response_data["access_token"]
# Check the new user can get his own info
response = Users().get_current_user(APP_URL, access_token)
assert response.ok
assert response.json()["username"] == new_username
assert response.json()["roles"] == new_user_roles
# Check that the newly created user CAN NOT create other users because
# it doesn't have admin privileges
response = Users().create_user(APP_URL, access_token, "tony", "montana")
assert not response.ok
# Check that the newly created user CAN NOT delete other users because
# it doesn't have admin privileges
response = Users().delete_user(APP_URL, access_token, new_user_id)
assert not response.ok
# Finally, delete the newly created user but this time use the admin account
response = Users().delete_user(APP_URL, login_as_admin, new_user_id)
assert response.ok
print '\tcheng'
print '\tbackstrom'
print '\tolim'
print '\tolimg'
print '\tlmm'
print '\thecht'
print '\tbackstrom'
print '\tkinsella'
exit()
args = {}
for i in range(1, len(sys.argv)):
key, value = sys.argv[i].split(':')
args[key] = value
test_users = Users()
test_users.load_file(args['test'])
training_users = Users()
training_users.load_file(args['training'])
ev = Evaluation(test_users)
if args['method'] == 'naiveg':
graph = Graph()
graph.load_file(args['graph'])
method = NaiveG(training_users, graph)
elif args['method'] == 'naivec':
db = DB(args['dbuser'], args['dbpass'], args['dbname'])
tweets = Tweets(db)
venues = Venues(db)
method = NaiveC(training_users, tweets, venues)
elif args['method'] == 'li':
from lib.users import Users
import json
from boto import kinesis
user = "******"
password = "******"
interval = 1500
count = 100
stream_name = "TestStream"
u = Users(user, password, interval, count)
x = u.list()
for line in x.iter_lines():
kinesis = kinesis.connect_to_region("eu-west-1")
kinesis.put_record(stream_name, line, "partitionkey")
if line:
print (line)
params = json.loads(f.read().rstrip())
f.close()
return params
def evaluate(inferred, answer):
for u in answer.iter():
v = inferred.get(u['id'])
if v['location'] != None:
print Util.hubeny_distance(v['location'], u['location'])
if len(sys.argv) < 8:
print '[usage]: python %s [training set] [test set] [params] [db user name] [db pass] [db name] [model file]' % sys.argv[
0]
exit()
training = Users()
training.load_file(sys.argv[1])
test = Users()
test.load_file(sys.argv[2])
params = load_params(sys.argv[3])
db = DB(sys.argv[4], sys.argv[5], sys.argv[6])
tweets = Tweets(db)
olim = OLIM(training, tweets, params)
""" quadtree partitioning """
if os.path.exists(sys.argv[7]):
f = open(sys.argv[7])
qtree = pickle.load(f)
f.close()