def login():
form = LoginForm()
if form.validate_on_submit():
user_name = form.username.data
password = form.password.data
user_model = UserModel(db.get_connection())
exists = user_model.exists(user_name, password)
print(exists)
if (exists[0]):
session['username'] = user_name
session['user_id'] = exists[1]
current_user_mode = exists[2]
return redirect("/index")
return render_template('login.html', title='Авторизация', form=form)
def reset_state(self):
self.asked_for_preference = False
self.selected_restaurand = None
self.user_model = UserModel()
self.current_state = ConverstationSates.Information
self.previous_response = ''
self.restaurant_info.reset()
def put(self, id):
data = request.get_json()
user = UserModel.find_by_id(id)
user.username = data["username"]
user.password = data["password"]
db.session.add(user)
db.session.commit()
return user.json()
def register():
form = RegisterForm()
if form.validate_on_submit():
name = form.username.data
password = form.password.data
passwordagain = form.password_again.data
email = form.email.data
user_type = form.mode.data
if password == passwordagain:
um = UserModel(db.get_connection())
um.insert(name, password, email, user_type)
exi = um.exists(name, password)
session['username'] = name
session['user_id'] = exi[1]
return redirect("/succes_register")
else:
return redirect("/passw_dont_match")
return render_template('register.html', form=form)
def is_exit(self, name, password):
user = UserModel(name, password)
sql = "select password from users where name = %s"
self.con.cur.execute(sql, [name])
data = self.con.cur.fetchone()
if not data:
return (False, None)
else:
return (True, data[0])
def load(cls, json):
instance = StorageModel()
entity_json = json['entity'] if 'entity' in json else None
permissions_json = json[
'permissions'] if 'permissions' in json else None
if not entity_json:
return None
instance.identifier = entity_json['id']
instance.name = entity_json['name']
instance.mask = entity_json['mask']
instance.type = entity_json['type']
instance.path = entity_json[
'pathMask'] if 'pathMask' in entity_json else None
if 'owner' in entity_json and entity_json['owner'].lower(
) != 'unauthorized':
user = UserModel()
user.username = entity_json['owner']
instance.users.append(user)
if permissions_json is not None:
for permission_json in permissions_json:
if 'sid' in permission_json and 'mask' in permission_json:
mask = int(permission_json['mask'])
if mask & 1 == 1 and mask & 4 == 4:
sid_json = permission_json['sid']
if 'principal' in sid_json and sid_json[
'principal'] and 'name' in sid_json:
user = UserModel()
user.username = sid_json['name']
instance.users.append(user)
return instance
def sample_users_from_population(self, query_duration):
if self.sampled_users:
self.sampled_users = []
# reset the seed so that the same users are
# generated every time this function is called
self.population_model.reset_random_seed()
# sampling user params for one user at a time
for ui in xrange(self.num_users):
A, D, V, L = self.population_model.generate_user_params()
self.sampled_users.append(UserModel(A, D, V, L))
# with open('debugging/py.all.users', 'w') as utf:
# for A,D,V,L in self.sampled_users:
# print >> utf, '\t'.join(map(str,[D,A,V]))
# sampling all user params all together for all users
# --> - results in 0.1 increase in score on average.
# - note that this is due to differences in random sampling order
# given the initial seed
# for user_params in self.population_model.generate_user_params(self.num_users):
# self.sampled_users.append(UserModel(*user_params))
# # with open('debugging/py.all.together.users', 'w') as utf:
# # for user in self.sampled_users:
# # print >> utf, '\t'.join(map(str,[user.D, user.A, user.V]))
# for each user generate session and away times
useri = 0
for user in self.sampled_users:
#user = UserModel(*user_params)
#user.generate_session_away_lengths(240*3600, True)
user.generate_session_away_lengths(query_duration, True)
# #logger.debug(str(len(user.session_away_durations)))
# with open('debugging/py.ssn.away.times.user-{}'.format(useri+1), 'w') as utf:
# for ssn, away in user.session_away_durations:
# print >> utf, '\t'.join(map(str,[ssn, away]))
useri += 1
proc_events[key][e.event_type].append(e)
proc_events[None][e.event_type].append(e)
if not isinstance(e, WindowChangeEvent) or window_event.filename_string() != key:
if not None in windowed_events:
windowed_events[None] = []
windowed_events[None].append(e)
if not key in windowed_events:
windowed_events[key] = []
windowed_events[key].append(e)
user_model = UserModel()
for window_event in proc_events:
window_model = gen_window_model(window_event, proc_events)
if window_model is None:
continue
user_model.add_window_model(window_event, window_model)
default_model = gen_window_model(None, proc_events)
user_model.set_default_model(default_model)
from db import DB
from user_model import UserModel
from news_model import NewsModel
from items_model import ItemsModel
db = DB()
users_model = UserModel(db.get_connection())
users_model.init_table()
users_model.insert("test1", "11111111", "*****@*****.**", "admin")
users_model.insert("admin", "password11", "*****@*****.**", "admin")
news_model = NewsModel(db.get_connection())
news_model.init_table()
items_model = ItemsModel(db.get_connection())
items_model.init_table()
items_model.insert("Defaul candy", "www.yandex.ru", "30",
"Classic candy with honey and cream.", "25")
120, # These values _do not_ matter since the sessions are going to be loaded from the trail files regardless
60,
10800,
5400,
args.lateness_decay)
outfnamepre = args.user_params[:-len("user.params")]
# load sessions from file
logger.warning('loading user reading speeds')
with open(args.user_params) as uf:
line = uf.readline()
#skip header
for line in uf:
A, D, V = [float(e) for e in line.strip().split('\t')]
MSU.sampled_users.append(UserModel(A, D, V, args.lateness_decay))
print >> sys.stderr, 'preloading sessions'
user_sessions = {}
user_ssn_starts = {}
for ui in xrange(args.num_users):
user_sim = MSU.sampled_users[ui]
uid = ui + 1
ttfile = outfnamepre + "time-trails/time-trail-user-" + str(uid)
with open(ttfile) as tf:
line = tf.readline() #skip header
for line in tf:
ssn_durn, time_away = [
float(e) for e in line.strip().split('\t')
]
user_sim.session_away_durations.append((ssn_durn, time_away))
def test_update_user(self):
username = '******'
password = '******'
# Read parameters
user = UserModel()
user.username = username
user.email = '*****@*****.**'
user.setPassword(password)
user.project = 'ReLDI'
user.requests_limit = 1000
user.requests_made = 0
user.status = 'active'
user.role = 'admin'
user.save()
dbUser = UserModel.getByUsername(user.username)
new_username = '******'
dbUser.username = new_username
dbUser.project = 'RelDI2'
dbUser.requests_limit = 2000
dbUser.requests_made = 4
dbUser.status = 'blocked'
dbUser.role = 'user'
dbUser.save()
dbUser = UserModel.getByUsername(new_username)
self.assertEqual(dbUser.username, new_username)
self.assertEqual(dbUser.project, 'RelDI2')
self.assertEqual(dbUser.requests_limit, 2000)
self.assertEqual(dbUser.requests_made, 4)
self.assertEqual(dbUser.status, 'blocked')
self.assertEqual(dbUser.role, 'user')
level=logging.INFO, datefmt='%m-%d %H:%M:%S'
)
if __name__ == '__main__':
logging_setup()
logging.info('=============== START RUNNING ===============')
preprocessor = Preprocessor(Config=Config)
preprocessor.load_news_vec_pool()
preprocessor.load_datas_for_user_model()
preprocessor.build_user_to_news_history_custom()
preprocessor.build_sampling_pool(top = 5000, at_least = 10)
preprocessor.build_id_pairs_from_history(at_least=3)
# preprocessor.build_vec_pairs_from_history(at_least=10)
preprocessor.load_datas_for_candidate_pool()
preprocessor.build_candidate_pool(top = 2000, at_least = 100)
user_model = UserModel(Config=Config)
user_model.load_news_history(by_id=True)
user_model.model_training_dict_version(start=0,
items=10,
N=10,
epochs=20,
batch_size=256,
model_type='GRU',
init_rnn_by_avg=False)
recommender = Recommender(Config=Config)
recommender.load_vec_pool()
recommender.build_annoy_indexer()
from user_model import UserModel user = UserModel()
def test_create_user(self):
username = '******'
# Read parameters
user = UserModel()
user.username = username
user.email = '*****@*****.**'
user.setPassword('000000')
user.project = 'ReLDI'
user.requests_limit = 1000
user.requests_made = 0
user.status = 'active'
user.role = 'admin'
user.logRequest()
user.logRequest()
user.save()
dbUser = UserModel.getByUsername(user.username)
self.assertEqual(dbUser.username, username)
self.assertEqual(dbUser.project, 'ReLDI')
self.assertEqual(dbUser.requests_limit, 1000)
self.assertEqual(dbUser.requests_made, 2)
self.assertEqual(dbUser.status, 'active')
self.assertEqual(dbUser.role, 'admin')
def delete(self, id):
user = UserModel.find_by_id(id)
db.session.delete(user)
db.session.commit()
return user.json()
cv2.rectangle(s_copy, (int(cl[0] * w) - 2, int(cl[1] * h) - 2),
(int(cl[0] * w) + 2, int(cl[1] * h) + 2), (0, 255, 0),
-1, 8)
return s_copy
if __name__ == '__main__':
wd = os.getcwd()
if len(sys.argv) < 4:
print("Must have filename argument!", file=sys.stderr)
sys.exit(1)
input_dir = sys.argv[1]
file = input_dir + "/user_model.mdl"
user_model = UserModel()
output = "."
if len(sys.argv) > 4:
output = sys.argv[4]
with open(file, "rb") as f:
user_model = pickle.load(f)
screenshot_file = sys.argv[2]
screenshot = cv2.imread(screenshot_file)
window_title = sys.argv[3]
def post(self):
data = request.get_json()
user = UserModel(username=data["username"], password=data["password"])
db.session.add(user)
db.session.commit()
return user.json(), 201
def test_login_user_invalid(self):
username = '******'
password = '******'
# Read parameters
user = UserModel()
user.username = username
user.email = '*****@*****.**'
user.setPassword(password)
user.project = 'ReLDI'
user.requests_limit = 1000
user.requests_made = 0
user.status = 'active'
user.role = 'admin'
user.save()
dbUser = UserModel.getByUsername(user.username)
with self.assertRaises(ValueError):
token = dbUser.generateToken('not this password')
def test_login_user(self):
username = '******'
password = '******'
# Read parameters
user = UserModel()
user.username = username
user.email = '*****@*****.**'
user.setPassword(password)
user.project = 'ReLDI'
user.requests_limit = 1000
user.requests_made = 0
user.status = 'active'
user.role = 'admin'
user.save()
dbUser = UserModel.getByUsername(user.username)
token = dbUser.generateToken(password)
self.assertIsNotNone(token)
def test_delete_user(self):
username = '******'
# Read parameters
user = UserModel()
user.username = username
user.email = '*****@*****.**'
user.setPassword('000000')
user.project = 'ReLDI'
user.requests_limit = 1000
user.requests_made = 0
user.status = 'active'
user.role = 'admin'
user.save()
dbUser = UserModel.getByUsername(user.username)
self.assertIsNotNone(dbUser)
dbUser.delete()
dbUser = UserModel.getByUsername(user.username)
self.assertIsNone(dbUser)
if __name__ == '__main__':
# Collect events until released
with keyboard.Listener(on_release=on_release) as klistener:
wd = os.getcwd()
event_constructor = EventConstructor()
if len(sys.argv) < 4:
print("Must have filename argument!", file=sys.stderr)
sys.exit(1)
input_dir = sys.argv[4]
file = input_dir + "/user_model.mdl"
user_model = UserModel()
with open(file, "rb") as f:
user_model = pickle.load(f)
output_dir = input_dir + "/tests/" + str(int(time.time()))
out_folder = output_dir
if not os.path.isdir(output_dir):
os.makedirs(output_dir, exist_ok=True)
try:
os.mkdir(output_dir)
except OSError as e:
#folder exists
pass
def process_inputs(input_dirs, output_dir):
event_constructor = EventConstructor()
events = []
window_event = default_window_event
for f in input_dirs:
file = f + "/" + "events.evnt"
if not os.path.isfile(file):
print("Cannot find file: " + file)
continue
with open(file, "r") as f:
for line in f:
events.append(event_constructor.construct(line))
events.append(Event(events[-1].timestamp+1, EventType.NONE))
events = sorted(events, key=lambda x : x.timestamp)
proc_events = {}
windowed_events = {}
for e in events:
key = window_event.filename_string()
if isinstance(e, WindowChangeEvent):
window_event = e
windows.append(e)
if not key in proc_events:
proc_events[key] = {}
if not e.event_type in proc_events[key]:
proc_events[key][e.event_type] = []
if not None in proc_events:
proc_events[None] = {}
if not e.event_type in proc_events[None]:
proc_events[None][e.event_type] = []
if normalise and not window_event == default_window_event:
e.change_window(window_event)
proc_events[key][e.event_type].append(e)
proc_events[None][e.event_type].append(e)
if not isinstance(e, WindowChangeEvent) or window_event.filename_string() != key:
if not None in windowed_events:
windowed_events[None] = []
windowed_events[None].append(e)
if not key in windowed_events:
windowed_events[key] = []
windowed_events[key].append(e)
user_model = UserModel()
for window_event in proc_events:
window_model = gen_window_model(window_event, proc_events, windowed_events)
if window_model is None:
continue
user_model.add_window_model(window_event, window_model)
if not window_event is None:
for input_file_num in range(len(input_dirs)):
screenshot = find(window_event, input_dirs[input_file_num] + "/images/")
cols = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (0, 255, 255), (255, 0, 255), (0, 0, 0)]
if not screenshot is None and os.path.isfile(screenshot):
img = cv2.imread(screenshot)
if not img is None:
ci = 0
h, w = img.shape[:2]
for c in window_model.clusters:
if c[-4:] == "DOWN":
for cl in window_model.clusters[c]:
print(cl)
cv2.rectangle(img,
(int(cl[0]*w)-2, int(cl[1]*h)-2),
(int(cl[0]*w)+2, int(cl[1]*h)+2),
cols[ci], -1, 8)
ci += 1
imgout = output_dir + "/imgs/"
if not os.path.isdir(imgout):
os.makedirs(imgout, exist_ok=True)
try:
os.mkdir(imgout)
except OSError as e:
#folder exists
pass
cv2.imwrite(imgout + window_event + ".png", img)
continue
default_model = gen_window_model(None, proc_events, windowed_events)
user_model.set_default_model(default_model)
for i in range(100):
print("Gen:", default_model.next())
if not os.path.isdir(output_dir):
os.makedirs(output_dir, exist_ok=True)
try:
os.mkdir(output_dir)
except OSError as e:
#folder exists
pass
with open(output_dir + "/user_model.mdl", "bw+") as f:
pickle.dump(user_model, f)
def get(self, id):
user = UserModel.find_by_id(id)
return user.json()
def test_status_block_user(self):
username = '******'
password = '******'
user = UserModel()
user.username = username
user.email = '*****@*****.**'
user.setPassword(password)
user.project = 'ReLDI'
user.requests_limit = 1000
user.requests_made = 0
user.status = 'active'
user.role = 'admin'
user.save()
dbUser = UserModel.getByUsername(user.username)
dbUser.block()
self.assertEqual(dbUser.status, 'blocked')
if __name__ == '__main__':
# Collect events until released
with keyboard.Listener(on_release=on_release) as klistener:
wd = os.getcwd()
event_constructor = EventConstructor()
if len(sys.argv) < 4:
print("Must have filename argument!", file=sys.stderr)
sys.exit(1)
input_dir = sys.argv[4]
file = input_dir + "/user_model.mdl"
user_model = UserModel()
with open(file, "rb") as f:
user_model = pickle.load(f)
output_dir = input_dir + "/tests/" + str(int(time.time()))
out_folder = output_dir
if not os.path.isdir(output_dir):
os.makedirs(output_dir, exist_ok=True)
try:
os.mkdir(output_dir)
except OSError as e:
#folder exists
pass
r'/index', 'Index',
r'/login', 'Login',
r'/list', 'List',
r'/delete_all', 'Delete_All',
r'/register', 'Register',
r'/user_info', 'User_info',
r'/list_dir', 'List_dir',
r'/group_by', 'Group_by',
)
app = web.application(urls, globals())
connection = pymongo.MongoClient('localhost', 27017)
db = connection.test
model = UserModel(db)
#Default page
class Index():
def GET(self):
return render.index()
#Get status of the mongo server
class Status:
def GET(self):
try:
res = db.last_status()
res['location'] = 'localhost'
res['port'] = 27017