def test_pa3(self):
testdata = zip([(1024, 77), (1024, 268), (1024, 462), (1024, 393),
(1024, 36955), (2048, 77), (2048, 36955), (2048, 788)],
[
"1024,77,4.3848,Memento (2000)",
"1024,268,2.8646,Batman (1989)",
"1024,462,3.1082,Erin Brockovich (2000)",
"1024,393,3.8722,Kill Bill: Vol. 2 (2004)",
"1024,36955,2.3524,True Lies (1994)",
"2048,77,4.8493,Memento (2000)",
"2048,36955,3.9698,True Lies (1994)",
"2048,788,3.8509,Mrs. Doubtfire (1993)",
])
data = DataIO(verbose=False)
data.load('testdata/ratings.csv',
items_file='testdata/movie-titles.csv')
model = UserModel(verbose=False, normalize=True)
model.build(data)
for ((u, i), s) in testdata:
self.assertTrue(
'%s' % s == '%d,%d,%.4f,%s' %
(u, i,
user_based_knn(model,
30, [data.new_user_idx(u)],
[data.new_item_idx(i)],
cosine,
promote_users=True,
normalize='centered'), data.title(i)))
def post(self):
json_input = request.get_json()
try:
data = user_schema.load(json_input)
except ValidationError as err:
abort(422, errors=err.messages)
try:
UserModel.objects.get(username=data['username'])
abort(
400,
errors=f"user {data['username']} is already registered.",
)
except DoesNotExist:
pass
user = UserModel(
username=data['username'],
password=generate_password_hash(data['password']),
role=data['role'],
)
user.save()
message = f"Successfully created user: {user.username}"
data = user_schema.dump(user)
data['message'] = message
return data, 201
def run(self):
print("working ...")
user = UserModel("nombre", "*****@*****.**")
r = requests.post(url='http://localhost:8000/users/',
data=user.getUserDictionary(),
auth=("zehemz", "isveckson"))
self.__callback.threadFinished(r)
print("Termine! ...")
def test_update(self):
UserModel.where(userid="1998080911").update(record=u"来电狂想/云南虫谷/无敌破坏王")
user = UserModel.where(userid="1998080911").select().next()
self.assertEquals(user.userid, "1998080911")
self.assertEquals(user.username, "strawberry")
self.assertEquals(user.password, "Leo980809")
self.assertEquals(user.record, u"来电狂想/云南虫谷/无敌破坏王")
def userView(user_id):
user = UserModel().user(user_id)
if request.method == 'PUT':
UserModel().updateUser(request.form)
elif request.method == 'POST':
UserModel().createUser(request.form)
elif request.method == 'DELETE':
UserModel().deleteUser(request.form['id'])
else:
return render_template('admin/user.html', user=user)
def post(self, deviceUUID: str) -> Response:
payload: dict = request.json
user1: UserModel = UserModel.get_user_by_name(name=payload['name'])
user2: UserModel = UserModel.get_user_by_device_uuid(
device_uuid=deviceUUID)
if any((user1, user2)):
return Response('exist name or deviceUUID', 205)
UserModel.create(name=payload['name'], device_uuid=deviceUUID)
return Response('', 201)
def register():
message = ''
form = forms.RegisterForm()
if form.is_submitted():
print(form.validate_on_submit())
if form.validate_on_submit():
d = json.dumps({
"fullname": form.name.data,
"email": form.email.data,
"password": form.password.data
})
d = user_schema_single.loads(d)
new_user = UserModel(fullname=d["fullname"],
email=d["email"],
password=d["password"])
db.session.add(new_user)
try:
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
return "User could not be saved."
return f"Welcome {form.name.data}."
else:
message = "Form is invalid."
return render_template('register.html', form=form, message=message)
def post(data):
json = request.json['accessRequest']
user = UserModel.find(email=json['email'])
if user is not None:
resp = jsonify({'status': 409, 'message': 'Conflict.'})
resp.status_code = 409
return resp
user = UserModel(email=json['email'],
firstname=json['firstname'],
lastname=json['lastname'],
username=json['firstname'] + '.' + json['lastname'],
status='pending',
employee_id=json['employee_id'],
password=json['password'])
if user.save():
user = user.find(username=user.username)
users = UserModel.find(role='administrator')
for u in users:
message = Message()
message.type = 'access-request'
message.to_user = u
resp = jsonify({'accessRequest': {'id': user.id}})
resp.status_code = 201
return resp
resp = jsonify({'status': 400, 'message': 'Bad Request.'})
resp.status_code = 400
return resp
def post(self):
"""
post to login
:return:
"""
output = {"status": 0, "message": ""}
uname = self.get_argument('uname')
passwd = self.get_argument('passwd')
user_info = UserModel.get_one_by_uname(uname)
if not user_info:
output["status"] = 1201
output["message"] = '用户不存在'
return self.write(json.dumps(output))
if user_info.status != 1:
output["status"] = 1202
output["message"] = '用户已停用'
return self.write(json.dumps(output))
_passwd = hashlib.md5(passwd).hexdigest()
user_info.passwd = str(user_info.passwd)
_passwd = str(_passwd)
if user_info.passwd != _passwd:
output["status"] = 1202
output["message"] = '密码错误'
return self.write(json.dumps(output))
passport = {"UNAME": uname, "UID": user_info.id, "UREALNAME": user_info.real_name}
passport = json.dumps(passport)
self.set_secure_cookie("UPASS", passport)
output['status'] = 1
output["message"] = "登陆成功"
output['redirect'] = '/'
return self.write(json.dumps(output))
def get(self):
# Access the identity of the current user with get_jwt_identity
current_user = UserModel.find_by_username(get_jwt_identity())
return {
'username': current_user.username,
'balance': current_user.balance
}
def setUp(self):
if list(ScoreModel.where(userid="1998080911").select()) == []:
create_score_instance(
"1998080911",
"0000000001",
"2018-12-1",
5,
u"电影肥肠好看哈哈哈哈哈哈",
1,
4
)
if list(ScoreModel.where(userid="1999022511").select()) == []:
create_score_instance(
"1999022511",
"0000000002",
"2018-12-7",
14,
u"还阔以，嘻嘻",
1,
3
)
if list(UserModel.where(userid="1999080611").select()) == []:
create_score_instance(
"1999080611",
"0000000003",
"2018-12-4",
60,
u"龙猫太可爱了",
1,
5
)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('username',
help='This field cannot be blank',
required=True)
parser.add_argument('password',
help='This field cannot be blank',
required=True)
parser.add_argument('repassword',
help='This field cannot be blank',
required=True)
data = parser.parse_args()
username = data.username
password = data.password
repassword = data.repassword
with db.connect() as conn:
try:
if (password == repassword):
insert_statement = UserModel.insert().values(
username=username, password=password)
conn.execute(insert_statement)
return jsonify({
'succeed':
'Successfully created user {}'.format(username)
})
else:
return jsonify({
'succeed':
False,
'msg':
'The user entered password doe not matches'
})
except sqlalchemy.exc.DatabaseError as e:
print(e)
def get(self):
'''
Returns a list of all users
:return:
Failure - Error codes: 500
Success - List: 200
'''
user_model = UserModel()
try:
users = user_model.get_all_users()
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return users, 200
def get(self):
'''
Returns a list of skills that match the parameters entered by the user
:return:
Failure - Error codes: 500
Success - List: 200
'''
params = request.args.to_dict()
user_model = UserModel()
try:
skills = user_model.find_skill_by_params(params)
except (DatabaseError, IntegrityError) as e:
return {"message": "Internal Server Error {}".format(e)}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return skills, 200
class TestUserModel(unittest.TestCase):
def setUp(self):
self.data = DummyDataset()
self.model = UserModel(verbose = False)
self.model.build(self.data)
def test_mean(self):
expected = np.matrix([[ 3.2 ],
[ 3.94 ],
[ 4.13333333]])
self.assertTrue(stringify_matrix(self.model.mean()) == stringify_matrix(expected))
def test_users(self):
expected = sparse.csr_matrix(
[[ 0.8 , -2.2 , 0.0 , 1.4 , 0.0 ],
[ 0.56 , 0.06 , -0.44 , -0.24 , 0.06 ],
[ 0.86666667, 0.0 , -0.73333333, 0.0 , -0.13333333]])
self.assertTrue(stringify_matrix(self.model.R().todense()) == stringify_matrix(expected.todense()))
def userLogin():
user = UserModel.valideteLogin(request.json['email'],
request.json['password'], mysql)
if (user != None):
return jsonify({
'email': user[0]['usr_email'],
'id': user[0]['usr_id']
})
else:
return jsonify({'email': '', 'id': ''})
def register_user(self, request):
query = UserModel.query(UserModel.user_name == request.user_name)
if query.count() != 0:
return StringMessage(content="name_exists")
query = UserModel.query(UserModel.email == request.email)
if query.count() != 0:
return StringMessage(content="email_exists")
UserModel(
user_name=request.user_name,
last_modified=date_to_utc(request.last_modified),
email=request.email,
uuid=request.uuid,
deleted=request.deleted,
).put()
return StringMessage(content="ok")
def comment(cls,id):
'''评论过的'''
if cls.exists24(id):
uid=EntryModel.uid_by_eid(id)
weight=1
if UserModel.has_pet(uid):
weight=1.5
cls._add_weight(id,weight)
else:
cls._add_weight48(id,2)
def get(self) -> Response:
teams = TeamModel.get_all_teams()
result = [{
'name':
team.team_name,
'member':
[user.name for user in UserModel.get_users_by_team(team)],
} for team in teams]
return jsonify(result)
def test_select(self):
users = UserModel.where().select()
for user in users:
if user.userid == "1998080911": pass
elif user.userid == "1999022511": pass
else:
self.assertEquals(user.userid, "1999080611")
self.assertEquals(user.username, "likemilk")
self.assertEquals(user.password, "woaihemilk")
self.assertEquals(user.record, u"龙猫/狗十三")
def admin_login(request):
user = UserModel.query(request.POST['username']).next()
if user == None:
return render(request, 'admin/login.html',
{'err_message': 'Wrong username or password!'})
if user.user_passcode == request.POST['password']:
request.session['user_id'] = user.user_name
return redirect('admin_index')
else:
return render(request, 'admin/login.html',
{'err_message': 'Wrong username or password!'})
def post(self):
data = parser.parse_args(strict=True)
current_user = UserModel.find_by_username(data['username'])
# make sure the user exists
if not current_user:
return {
'message': 'User {} doesn\'t exist'.format(data['username'])
}
# check if the provided password is correct
if UserModel.verify_hash(data['password'], current_user.password):
access_token = create_access_token(identity=data['username'])
refresh_token = create_refresh_token(identity=data['username'])
return {
'message': 'Logged in as {}'.format(current_user.username),
'access_token': access_token,
'refresh_token': refresh_token
}
else:
return {'message': 'Wrong credentials'}
def get(self, _id):
'''
Takes in an int as an id and returns the dictionary of the User
:param _id:
:return:
Failure - Error codes: 500, 404
Success - Dictionary: 200
'''
user_model = UserModel()
try:
user = user_model.get_by_id(_id)
except DataError:
return {
"message": "User with ID {} does not exist".format(_id)
}, 404
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return user.get_fields(), 200
def post(self):
data = parser.parse_args(strict=True)
# check if user exists already
if UserModel.find_by_username(data['username']):
return {
'message': 'User {} already exists'.format(data['username'])
}
# create a new user
new_user = UserModel(username=data['username'],
password=UserModel.generate_hash(
data['password']))
# attempt saving user to the DB
try:
new_user.save_to_db()
# create temporary access token
access_token = create_access_token(identity=data['username'])
refresh_token = create_refresh_token(identity=data['username'])
return {
'message': 'User {} was created'.format(data['username']),
'access_token': access_token,
'refresh_token': refresh_token
}
except:
return {
'message': 'Something went wrong while creating the user'
}, 500
def put(self, _id, **kwargs):
'''
Takes in an int as an id and updates the user with the validated payload
:param _id:
:return:
Failure - Error codes: 500, 404
Success - Dictionary: 200
'''
payload = kwargs.get('payload', None)
user_model = UserModel()
try:
user = user_model.update_user(_id, payload)
except DataError:
return {
"message": "User with ID {} does not exist".format(_id)
}, 404
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return user.get_fields(), 200
def test_pa3(self):
testdata = zip([(1024,77),(1024,268),(1024,462),(1024,393),(1024,36955),(2048,77),(2048,36955),(2048,788)],
[
"1024,77,4.3848,Memento (2000)",
"1024,268,2.8646,Batman (1989)",
"1024,462,3.1082,Erin Brockovich (2000)",
"1024,393,3.8722,Kill Bill: Vol. 2 (2004)",
"1024,36955,2.3524,True Lies (1994)",
"2048,77,4.8493,Memento (2000)",
"2048,36955,3.9698,True Lies (1994)",
"2048,788,3.8509,Mrs. Doubtfire (1993)",
])
data = DataIO(verbose = False)
data.load('testdata/ratings.csv', items_file = 'testdata/movie-titles.csv')
model = UserModel(verbose = False, normalize = True)
model.build(data)
for ((u,i),s) in testdata:
self.assertTrue('%s' % s ==
'%d,%d,%.4f,%s' % (u,i,user_based_knn(model, 30, [data.new_user_idx(u)],[data.new_item_idx(i)],
cosine, promote_users = True, normalize = 'centered'), data.title(i)))
def post(self):
# validate request
data = transaction_parser.parse_args()
# make sure the target user exists
target_user = UserModel.find_by_username(data['target'])
# make sure the user exists
if not target_user:
return {
'message':
'Target user {} doesn\'t exist'.format(data['target'])
}
# check if the user has the credit he wants to transfer
current_user = UserModel.find_by_username(get_jwt_identity())
amount = float(data['amount'])
if amount <= 0.0:
return {
'message':
'A transaction is expected to have an amount greater than 0'
}
if current_user.balance < amount:
return {
'message':
'User {} requested to transfer {} to user {}, however the credit is not enough'
.format(data['username'], data['amount'], data['target'])
}
# if we reached here the target user exists and we have enough credit, then perform the transaction
try:
UserModel.transact(current_user, amount, target_user)
return {
'message':
'Successfully moved {} from {} to {}'.format(
data['amount'], data['username'], data['target'])
}
except:
return {
'message':
'Something went wrong while moving {} to user {}'.format(
data['amount'], target_user.username)
}, 500
def setUp(self):
if list(UserModel.where(userid="1998080911").select()) == []:
create_user_instance(
"1998080911",
"strawberry",
"Leo980809",
u"来电狂想/云南虫谷/无敌破坏王"
)
if list(UserModel.where(userid="1999022511").select()) == []:
create_user_instance(
"1999022511",
"mu001999",
"woaini18",
u"海王/蜘蛛侠"
)
if list(UserModel.where(userid="1999080611").select()) == []:
create_user_instance(
"1999080611",
"likemilk",
"woaihemilk",
u"龙猫/狗十三"
)
def create_user_instance(
userid,
username,
password,
record
):
user = UserModel()
user.userid = userid
user.username = username
user.password = password
user.record = record
user.save()
return user
def post(self):
_passwd = self.get_argument('passwd', False)
_new_passwd = self.get_argument('new_passwd', False)
_confirm_passwd = self.get_argument('confirm_passwd', False)
output = {"status": 0, "message": ""}
if not _passwd or not _new_passwd or not _confirm_passwd:
output["status"] = 1101
output["message"] = "参数不完整"
return self.write(json.dumps(output))
if _confirm_passwd != _new_passwd:
output["status"] = 1102
output["message"] = "两次密码不一致"
return self.write(json.dumps(output))
users = self.current_user
uid = users["uid"]
_passwd = hashlib.md5(_passwd).hexdigest()
user_info = UserModel.get_one(uid)
if not user_info:
output["status"] = 1104
output["message"] = "该用户不存在"
return self.write(json.dumps(output))
if user_info.passwd != _passwd:
output["status"] = 1105
output["message"] = "原密码错误, 不允许修改"
return self.write(json.dumps(output))
_new_passwd = hashlib.md5(_new_passwd).hexdigest()
result = UserModel.update(uid, passwd=_new_passwd)
if result:
output["status"] = 1
output["message"] = "SUCCESS"
return self.write(json.dumps(output))
output["status"] = 1103
output["message"] = "异常错误"
return self.write(json.dumps(output))
class UserAccountService:
def __init__(self):
self.model = UserModel()
def create_user(self, params):
result = self.model.create_user(params["user_name"], params["email"],
params["karma"])
return result
def update_email(self, params):
result = self.model.update_email(params["user_name"], params["email"])
return result
def increment_karma(self, params):
result = self.model.increment_karma(params["user_name"])
return result
def decrement_karma(self, params):
result = self.model.decrement_karma(params["user_name"])
return result
def deactivate_account(self, params):
result = self.model.deactivate_account(params["user_name"])
return result
def delete(self, _id):
'''
Takes in an int as an id and deletes the user with the id
:param _id:
:return:
:param _id:
:return:
Failure - Error codes: 500, 404
Success - No Content: 204
'''
user_model = UserModel()
try:
user_model.delete_user(_id)
except DataError:
return {
"message": "User with ID {} does not exist".format(_id)
}, 404
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return {}, 204
def test_i_registered(self):
UserModel.Profile(email="*****@*****.**",
first_name="Amadeus",
last_name="Motzart",
date_of_birth="1961-01-01",
age=59,
gender="Male",
image_url="abc",
description="Musician").save()
reqaa = RequestService.is_registered("*****@*****.**")
# reqab = RequestService.isRegistered("*****@*****.**")
self.assertTrue(reqaa)
def user_list(self, unused_request):
qry = UserModel.query()
my_items = []
for user in qry:
my_items.append(
UserMessage(
user_name=user.user_name,
last_modified=user.last_modified,
email=user.email,
uuid=user.uuid,
deleted=user.deleted,
)
)
return UserMessageCollection(items=my_items)
async def post(self, user_id=None):
"""
summary: Создать пользователя
description: тест
"""
user = self.get_body(UserModel)
try:
user = UserModel(**user)
except ValidationError as e:
return self.finish_with_error()
try:
user_id = await self.application.db.users.create(user)
except Exception as e: # DatabaseException
return self.finish_with_error()
return self.finish_with_ok(
BaseResponse(status_code=200, reason='user_created', data=user_id))
def user_sync_down(self, request):
query = UserModel.query(UserModel.last_modified > string_to_datetime(request.date))
my_items = []
for user in query:
my_items.append(
UserMessage(
user_name=user.user_name,
last_modified=user.last_modified,
email=user.email,
uuid=user.uuid,
deleted=user.deleted,
)
)
return UserMessageCollection(items=my_items)
async def get(self, user_id: UUID):
"""
summary: Получение информации о пользователе по id
description: тест
"""
try:
user = dict(
name='samuel colvin',
username='******',
password1='zxcvbn',
password2='zxcvbn',
)
user = UserModel(**user)
return self.finish_with_ok(
BaseResponse(status_code=200, reason='user_found', data=user))
except ValidationError as e:
return self.finish_with_error(
BaseResponse(status_code=422, reason='validation error'))
def post(self):
json = request.json['user']
user = UserModel(firstname=json['firstname'],
lastname=json['lastname'],
email=json['email'],
username=json['firstname'] + '.' + json['lastname'],
employee_id=json['employee_id'],
status=json['status'],
password=''.join(
random.choice(string.ascii_uppercase +
string.digits) for _ in range(12)),
role=json['role'])
for department in json['departments']:
user.departments.append(Department.find(id=department['id']))
user.save()
departments = []
for department in user.departments:
departments.append({
'id': department.id,
'parent_id': department.parent_id,
'name': department.name,
'description': department.description
})
model = {
'user': {
'id': user.id,
'user_id': user.id,
'firstname': user.firstname,
'lastname': user.lastname,
'email': user.email,
'username': user.username,
'employee_id': user.employee_id,
'status': user.status,
'role': user.role,
'departments': departments
}
}
print model
return jsonify(model), 201
def post(self):
output = {"status": 0, "message": ""}
_id = self.get_argument('id', 0)
try:
_id = int(_id)
except ValueError:
_id = 0
if _id == 0:
output["status"] = 1101
output["message"] = "参数ID错误"
return self.write(json.dumps(output))
result = UserModel.remove(_id)
print type(result)
if result:
output["status"] = 1
output["message"] = "SUCCESS"
else:
output["status"] = 1101
output["message"] = "参数ID错误"
return self.write(json.dumps(output))
def user_insert(self, request):
query = UserModel.query(UserModel.uuid == request.uuid)
if query.count() == 0:
UserModel(
user_name=request.user_name,
last_modified=date_to_utc(request.last_modified),
email=request.email,
uuid=request.uuid,
deleted=request.deleted,
).put()
else:
user = query.get()
user.user_name = request.user_name
user.last_modified = date_to_utc(request.last_modified)
user.email = request.email
user.deleted = request.deleted
user.put()
return message_types.VoidMessage()
def __init__(self):
self.user=UserModel.instance()
self.note=NoteModel.instance()
self.comment=CommentModel.instance()
self.relation=RelationModel.instance()
self.notification = NotificationModel.instance()
def setUp(self):
self.data = DummyDataset()
self.model = UserModel(verbose = False)
self.model.build(self.data)
def create_user(name):
#清表
u=UserModel(name=name,has_pet=False)
u.insert()
print '创建用户:',u.name
return u
def get(self):
lists = UserModel.get_all()
self.render('user/index.html', lists=lists, user=self.current_user)
pass
def post(self):
_uname = self.get_argument('uname', False)
_passwd = self.get_argument('passwd', False)
_real_name = self.get_argument('real_name', False)
_status = self.get_argument('status', 1)
status_dict = {1: "正常", 2: "停用"}
output = {"status": 0, "message": ""}
if not _uname or not _real_name or not _status:
output["status"] = 1101
output["message"] = '参数不齐'
return self.write(json.dumps(output))
_uid = self.get_argument('uid', False)
if _uid:
try:
_uid = int(_uid)
except ValueError:
output["status"] = 1102
output["message"] = '错误的用户ID'
return self.write(json.dumps(output))
try:
_status = int(_status)
except ValueError:
_status = 1
if _status != 1 and _status != 2:
output["status"] = 1105
output["message"] = '错误的用户状态'
return self.write(json.dumps(output))
if _passwd:
_passwd = hashlib.md5(_passwd).hexdigest()
if _uid > 0:
update_params = {}
if _real_name:
update_params["real_name"] = _real_name
if _status:
update_params["status"] = _status
if _passwd:
update_params["passwd"] = _passwd
result = UserModel.update(uid=_uid, **update_params)
if result:
output["status"] = 1
output["message"] = 'SUCCESS'
output["data"] = {}
output["data"]["uid"] = _uid
output["data"]["real_name"] = _real_name
output["data"]["status"] = _status
output["data"]["_status"] = status_dict[_status]
return self.write(json.dumps(output))
else:
if not _passwd:
output["status"] = 1101
output["message"] = '请输入密码'
return self.write(json.dumps(output))
user_info = UserModel.get_one_by_uname(_uname)
if user_info:
output["status"] = 1104
output["message"] = '用户已存在,请重新输入'
return self.write(json.dumps(output))
result = UserModel.create(uname=_uname, passwd=_passwd, real_name=_real_name, status=_status)
if result:
output["status"] = 1
output["message"] = 'SUCCESS'
output["data"] = {}
output["data"]["uid"] = result.id
output["data"]["uname"] = result.uname
output["data"]["real_name"] = result.real_name
output["data"]["status"] = _status
output["data"]["_status"] = status_dict[result.status]
return self.write(json.dumps(output))
output["status"] = 1103
output["message"] = '出现错误,请重试'
return self.write(json.dumps(output))
def setUp(self):
self.data = DataIO(verbose = False)
self.data.load('testdata/ratings-ma4.csv')
self.model = UserModel(normalize = False, verbose = False)
self.model.build(self.data)
from dataset import DataIO
from model import UserModel
from suggest import top_ns
ratings_file = "ratings.csv"
given_users = [3867, 860]
NN = 5
n = 3
part_1_file = "part_1.csv"
part_2_file = "part_2.csv"
# part 1
data = DataIO()
data.load(ratings_file)
model = UserModel(normalize=False)
model.build(data)
given_users = data.translate_users(given_users)
given_items = range(data.num_items())
R = user_based_knn(model, NN, given_users, given_items, pearson, promote_users=False)
recs = top_ns(R, n, keep_order=True)
file = open(part_1_file, "w")
file.write("\n".join(["%d %.3f" % (data.old_item_idx(i), s) for u in recs for (i, s) in u]))
file.close()
# part 2
R = user_based_knn(
class WA4Test(unittest.TestCase):
def setUp(self):
self.data = DataIO(verbose = False)
self.data.load('testdata/ratings-ma4.csv')
self.model = UserModel(normalize = False, verbose = False)
self.model.build(self.data)
def test_pearson(self):
# test correlation
S = pearson(self.model.R(), self.model.R()).todense()
# 1. check we don't have numbers more than 1
# user string comparison to avoid float nuances
self.assertTrue('%.2f' % S.max() == '1.00');
# 2. check there are only '1' on the diagonal
self.assertTrue(sum([S[i,i] for i in range(S.shape[0])]) == S.shape[0])
# 3. check a couple of correlation coefficients
corr_test = [(1648, 5136, 0.40298),
(918, 2824, -0.31706)]
for (u1,u2,c) in corr_test:
# check what's in the full matrix
u1 = self.data.new_user_idx(u1)
u2 = self.data.new_user_idx(u2)
# check precomputed
self.assertTrue('%.5f' % S[u1,u2] == '%.5f' % c)
# compute here
self.assertTrue('%.5f' % pearson(self.model.R()[u1,:], self.model.R()[u2,:]).todense() == '%.5f' % c)
def test_5nn(self):
u = 3712
nns = [(2824,0.46291), (3867,0.400275), (5062,0.247693), (442,0.22713), (3853,0.19366)]
S = pearson(self.model.R(), self.model.R())
leave_top_n(S,6)
top_neighbours = [(self.data.old_user_idx(i),S[i,self.data.new_user_idx(u)])
for i in S[:,self.data.new_user_idx(u)].nonzero()[0]]
top_neighbours.sort(key = lambda a: a[1], reverse = True)
# skip the first element (corr = 1)
self.assertTrue(','.join(['%d,%.6f' % a for a in top_neighbours[1:]]) ==
','.join(['%d,%.6f' % a for a in nns]))
# consider moving this test to test_recsys.py
def test_unnormalized(self):
u = 3712
expected = [(641,5.000), (603,4.856), (105,4.739)]
R = user_based_knn(self.model, 5, [self.data.new_user_idx(u)], range(self.data.num_items()),
pearson, promote_users = False)
recs = top_ns([R],3, keep_order = True)
self.assertTrue(','.join(['%d,%.3f' % (self.data.old_item_idx(a),b) for (a,b) in recs[0]]) ==
','.join(['%d,%.3f' % a for a in expected]))
# consider moving this test to test_recsys.py
def test_normalized(self):
u = 3712
expected = [(641,5.900), (603,5.546), (105,5.501)]
R = user_based_knn(self.model, 5, [self.data.new_user_idx(u)], range(self.data.num_items()),
pearson, promote_users = False, normalize = 'normalize')
recs = top_ns([R],3, keep_order = True)
self.assertTrue(','.join(['%d,%.3f' % (self.data.old_item_idx(a),b) for (a,b) in recs[0]]) ==
','.join(['%d,%.3f' % a for a in expected]))
