def test_get_score(self):
fields = {
'phone': '5555555',
'email': '*****@*****.**',
}
# start redis server
redis_server = subprocess.Popen(shlex.split('redis-server --port %s' %
REDIS_PORT),
shell=False,
stdout=subprocess.PIPE,
stderr=sys.stderr)
redis_client = redis.Redis(host='localhost',
port=REDIS_PORT,
socket_connect_timeout=0.5,
socket_timeout=0.5)
st = store.Store(port=REDIS_PORT)
key = "uid:" + hashlib.md5(fields['phone']).hexdigest()
value = 1
redis_client.set(key, value)
self.assertEqual(get_score(st, **fields), value)
redis_client.delete(key)
redis_server.terminate()
redis_server.wait()
self.assertEqual(get_score(st, **fields), 3)
def test_exception_get_score(self, error, kwargs):
"""scoring.get_score не падает при недоступности хранилища"""
st = self.get_store()
st.redis.execute_command = mock.PropertyMock(
side_effect=error) # mock execute_command to raise exception
try:
scoring.get_score(st, **kwargs)
except error as e:
pytest.fail("Unexpected error {0}".format(type(e)))
class TestScoring(TestCase):
@cases([
({
'phone': '5555555',
'email': '*****@*****.**',
'birthday': datetime(2020, 1, 1),
'gender': 1,
'first_name': 'first',
'last_name': 'last'
}, 5),
({
'email': '*****@*****.**',
'birthday': datetime(2020, 1, 1),
'gender': 1,
'first_name': 'first',
'last_name': 'last'
}, 3.5),
({
'birthday': datetime(2020, 1, 1),
'gender': 1,
'first_name': 'first',
'last_name': 'last'
}, 2),
({
'gender': 1,
'first_name': 'first',
'last_name': 'last'
}, 0.5),
({
'birthday': datetime(2020, 1, 1),
'first_name': 'first',
'last_name': 'last'
}, 0.5),
({
'birthday': datetime(2020, 1, 1),
'gender': 1,
'last_name': 'last'
}, 1.5),
({
'birthday': datetime(2020, 1, 1),
'gender': 1,
'first_name': 'first',
}, 1.5),
({}, 0),
])
def test_get_score(self, (field_set, score_value)):
store = Store()
self.assertEqual(get_score(store, **field_set), score_value)
store = Store(score=1)
self.assertEqual(get_score(store, **field_set), 1)
def test_get_score(self):
fields = {
'phone': '5555555',
'email': '*****@*****.**',
}
key = "uid:" + hashlib.md5(fields['phone']).hexdigest()
value = 1
self.redis.set(key, value)
self.assertEqual(get_score(self.store, **fields), value)
self.redis.delete(key)
self.assertEqual(get_score(self.store, **fields), 3)
def online_score_progress(method_request, ctx, store):
request = OnlineScoreRequest(method_request.arguments)
request.valid_required_field()
if request.error_field:
return "<Invalid fields: %s>" % (request.error_field), INVALID_REQUEST
ctx['has'] = [field for field in request.arguments_fied.keys() if getattr(request, field)]
if method_request.is_admin:
return {"score": 42}, OK
if request.phone and request.email or \
request.first_name and request.last_name or \
request.gender and request.birthday:
response = {
"score": get_score(
store, request.phone,
request.email, request.birthday,
request.gender, request.first_name,
request.last_name)}
return response, OK
else:
invalid_field = [field for field in request.arguments_fied.keys() if not getattr(
request, field)]
return "<Invalid fields: %s>" % (invalid_field), INVALID_REQUEST
def online_score_method(arguments, is_admin, context, store):
"""
Метод 'online_score'
:param ArgumentsField arguments: аргументы вызываемеого метода
:param bool is_admin: является ли пользователь администратором
:param dict context: словарь контекста
:param store: хранилище
:return: число
:rtype: int
"""
request = OnlineScoreRequest(**arguments.value)
valid, errors = request.validate_request()
if not valid:
return INVALID_REQUEST, '\n'.join(errors)
context.setdefault('has', request.get_not_empty_fields())
if is_admin:
return OK, {"score": ADMIN_SALT}
else:
return OK, {
"score":
scoring.get_score(store=store,
phone=request.phone.value,
email=request.email.value,
birthday=request.birthday.value,
gender=request.gender.value,
first_name=request.first_name.value,
last_name=request.last_name.value)
}
def online_score_handler(mr, ctx, store):
"""
Обработчик для запросов по скорингу online_score
:param dict request:
:param dict ctx:
:param store:
:return dict:
"""
score_req = OnlineScoreRequest(mr.arguments)
if not score_req.is_valid():
raise ValidationError(score_req.errors)
if not score_req.validate_arguments():
raise InvalidRequest(u"Not enough arguments in request: {}".format(mr.arguments))
if mr.is_admin:
score = 42
else:
score = get_score(None, score_req.phone, score_req.email, score_req.birthday, score_req.gender,
score_req.first_name, score_req.last_name)
ctx.update({'has': score_req.get_filled_fields()})
response = {'score': score}
return response
def method_handler(request, ctx, store):
response, code = {}, None
request_body = request['body']
logging.info('request body is: {}'.format(request_body))
try:
main_request = MethodRequest(request_body)
if not check_auth(main_request):
code = 403
return response, code
if main_request.method == 'online_score':
method_request = OnlineScoreRequest(main_request.arguments)
ctx['has'] = [i for i in method_request.get_fields().keys()]
if main_request.is_admin:
response = {"score": 42}
else:
response = {
"score": get_score(None, **method_request.get_fields())
}
elif main_request.method == 'clients_interests':
method_request = ClientsInterestsRequest(main_request.arguments)
ctx['nclients'] = len(method_request.client_ids)
for id in method_request.client_ids:
response[id] = get_interests(None, id)
code = 200
return response, code
except AttributeError as e:
response = e.args[0]
code = 422
return response, code
def handle(self, request_dict, *extra):
admin_role = extra[0] is True
ctx = extra[1]
store = extra[2]
# basic validations
response, code = self.validate_fields(request_dict)
# extra validation
if code == OK:
if not self.check_fields_actual(request_dict, ('phone','email')) and \
not self.check_fields_actual(request_dict,('first_name','last_name')) and \
not self.check_fields_actual(request_dict,('gender','birthday')):
return {
'error': "not enough arguments for 'online_score' method"
}, INVALID_REQUEST
# processing
if code == OK:
scoring_params = ('phone', 'email', 'birthday', 'gender',
'first_name', 'last_name')
ctx['has'] = [
x for x in scoring_params
if self.check_fields_actual(request_dict, (x, ))
]
if admin_role:
response = {'score': int(ADMIN_SALT)}
else:
args = (request_dict.get(x) for x in scoring_params)
response = {'score': scoring.get_score(store, *args)}
return response, code
def online_scor_handler(request: MethodRequest, ctx: dict) -> tuple:
"""Обработка запроса с подсчетом скор-балла"""
online_score = OnlineScoreRequest(request.arguments)
if online_score.error is not None:
code = 422
response = online_score.error
elif not online_score.validate_args_func():
code = 422
response = 'Not enough data in arguments'
else:
ctx['has'] = online_score.define_has(request.arguments)
if request.is_admin_func:
code = 200
response = {"score": 42}
else:
scor = scoring.get_score(
phone=online_score.phone,
email=online_score.email,
birthday=online_score.birthday,
gender=online_score.gender,
first_name=online_score.first_name,
last_name=online_score.last_name,
)
code = 200
response = dict(score=scor)
return code, response
def method_handler(request, ctx, store):
response, code = None, None
request = request['body']
request_user = MethodRequest(**vars(request))
if request.method == 'online_score' and not request_user.is_admin:
data = request.arguments
try:
obj = OnlineScoreRequest(**data)
response = get_score(store, obj.phone, obj.email, obj.birthday,
obj.gender, obj.first_name, obj.last_name)
code = OK
except Exception as ex:
response = str(ex)
code = BAD_REQUEST
elif request.method == 'online_score' and request_user.is_admin:
response = {"score": 42}
code = OK
elif request.method == 'clients_interests':
try:
clients = ClientsInterestsRequest(**request.arguments)
except ValidationError as ex:
response = str(ex)
code = BAD_REQUEST
else:
response = {}
for client in clients.client_ids:
client_response = get_interests(store, client)
response.update([(str(client), client_response)])
code = OK
return response, code
def test_on_disconnected_store_get_score(self, kwargs):
self.store = Store(port=9999, connect_timeout=1, attempts=1)
score = kwargs.pop('score')
kwargs['birthday'] = api.DateField.str_to_date(kwargs['birthday'])
self.assertAlmostEqual(scoring.get_score(self.store, **kwargs),
score,
delta=0.1)
def execute_request(self, arguments, context, store):
if not self.verification(arguments):
return self.post_method.show_errors(), INVALID_REQUEST
clean_dict = self.post_method.cleaned_data
if not self.check_non_empty_pairs(clean_dict):
return "Checking non empty pairs failed!", INVALID_REQUEST
context['has'] = sorted(
[k for k, v in clean_dict.items() if self.is_true(v)])
scores = scoring.get_score(
store,
clean_dict.get('phone'),
clean_dict.get('email'),
clean_dict.get('birthday'),
clean_dict.get('gender'),
clean_dict.get('first_name'),
clean_dict.get('last_name'),
)
if context.get('is_admin'):
return {'score': 42}, OK
return {'score': scores}, OK
def onine_score_handler(arguments, **extra):
ctx = extra['ctx']
store = extra['store']
is_admin = extra['is_admin']
request = OnlineScoreRequest(arguments)
# basic validations
if not request.is_valid():
response = {'error': ERRORS[INVALID_REQUEST] + ': '}
if request.extra_valid_error:
response['error'] += request.extra_valid_error + '.'
elif request.errors:
response['error'] += '; '.join(request.errors.values()) + '.'
return response, INVALID_REQUEST
# processing
ctx['has'] = [
x for x in request.fields if hasattr(request, x)
and not request.fields[x].check_null(getattr(request, x))
]
if is_admin:
response = {'score': int(ADMIN_SALT)}
else:
args = (getattr(request, x, None)
for x in ('phone', 'email', 'birthday', 'gender', 'first_name',
'last_name'))
response = {'score': scoring.get_score(store, *args)}
return response, OK
def handle_online_score_request(method_request: MethodRequest, store,
context) -> Tuple[Dict, str]:
"""
Handles online score request
"""
online_score_request = OnlineScoreRequest(
request_body=method_request.arguments)
request_is_valid, errors = online_score_request.is_valid()
if not request_is_valid:
return errors, INVALID_REQUEST
admin_score_response = 42
score = admin_score_response if method_request.is_admin else get_score(
store=store,
email=online_score_request.email,
birthday=online_score_request.birthday,
gender=online_score_request.gender,
first_name=online_score_request.first_name,
last_name=online_score_request.last_name,
phone=online_score_request.phone)
response = {"score": score}
context["has"] = [
field_val[0] for field_val in online_score_request.fields
if online_score_request.__dict__.get(field_val[0]) is not None
]
return response, OK
def test_ok_get_score(self, arguments):
phone, birthday, first_name, last_name, email, gender, score = arguments
score = scoring.get_score(self.fake_store, phone=phone, birthday=birthday, email=email, gender=gender,\
first_name=first_name, last_name=last_name)
key = scoring.get_key(first_name, last_name, phone, birthday)
r = fakeredis.FakeStrictRedis(server=self.fake_redis_server)
self.assertEqual(float(r.get(key)), score)
def process(self, ctx=None, store=None):
score = scoring.get_score(None, self.phone, self.email, self.birthday,
self.gender, self.first_name, self.last_name)
actual_fields = [f for f in self.fields if not f == None]
ctx.update({'has': actual_fields})
return {"score": score}
def test_get_score(self):
fields = {
'phone': '5555555',
'email': '*****@*****.**',
}
st = store.Store()
self.assertEqual(get_score(st, **fields), 3)
def choose_highest_score(scored_map):
max_score, max_edge = 0,None
for edge in scored_map.edges_iter():
score = get_score(scored_map, edge)
if score > max_score:
max_score = score
max_edge = edge
return max_edge
def method_handler(self, method_req, request, context, store):
if request.is_admin:
score = 42
else:
score = get_score(store, method_req.phone, method_req.email, method_req.birthday, method_req.gender,
method_req.first_name, method_req.last_name)
context["has"] = method_req.non_empty_fields
return {"score": score}, OK
def score(self, store):
dic = {
'first_name': self.first_name,
'last_name': self.last_name,
'birthday': self.birthday,
'gender': self.gender
}
return scoring.get_score(store, self.phone, self.email, **dic)
def get_season_data(
years=[2018],
weeks=list(range(1, 18)),
positions=['QB', 'RB', 'WR', 'TE', 'DST'],
league='FanDuel',
):
act = {}
proj = {}
for year in years:
for week in weeks:
for pos in positions:
# projections
fid = f'../data/{year}/{week}/{pos}/NFL.csv'
projdf = pd.read_csv(fid)
proj[(year, week, pos)] = get_score(
projdf,
pos=pos,
type='Proj',
league=league,
)
# actual stats
fid = f'../data/{year}/{week}/{pos}/STATS.csv'
actdf = pd.read_csv(fid)
act[(year, week, pos)] = get_score(
actdf,
pos=pos,
type='Actual',
league=league,
)
projdf = pd.concat(proj)
projdf = projdf.reset_index().drop('level_2 level_3'.split(), axis=1)
projdf.columns = 'year week player team pos proj'.split()
projdf.set_index('year week player team pos'.split(), inplace=True)
actdf = pd.concat(act)
actdf = actdf.reset_index().drop('level_2 level_3'.split(), axis=1)
actdf.columns = 'year week player team pos actual'.split()
actdf.set_index('year week player team pos'.split(), inplace=True)
df = projdf.join(actdf, how='left')
df.dropna(inplace=True)
df.reset_index(inplace=True)
return df
def get_score_response(request, ctx, store, is_admin=False):
resp = {}
fields = request.get_none_empty_fields()
if is_admin:
resp['score'] = 42
else:
resp['score'] = get_score(store, **fields)
ctx['has'] = fields.keys()
return resp
def handle(self, request, arguments, ctx, store):
score = self.ADMIN_SCORE
if not request.is_admin:
score = scoring.get_score(
store, arguments.phone, arguments.email, arguments.birthday, arguments.gender,
arguments.first_name, arguments.last_name
)
ctx['has'] = [field.name for field in self.type.fields if getattr(arguments, field.name)]
return {'score': score}, OK
def get_result(self, ctx, store, is_admin=False):
self._fill_context(ctx)
if is_admin:
return {"score": 42}
return {
"score":
scoring.get_score(store, self.phone, self.email, self.birthday,
self.gender, self.first_name, self.last_name)
}
def get_response(self, ctx, store, is_admin=False):
ctx["has"] = [
f for f in self.req_args if f not in self.fields[f].null_values
]
score = 42
if not is_admin:
score = scoring.get_score(store, self.phone, self.email,
self.birthday, self.gender,
self.first_name, self.last_name)
return {"score": score}, OK
def process_online_score_interests_request(request, ctx, store):
ctx["has"] = request.filled_fields()
return {
"score":
42 if request.request.is_admin else get_score(
store, request.phone, request.email,
BirthDayField.get_date(request.birthday), request.gender,
request.first_name, request.last_name)
}, OK
def online_score_request_handler(request, ctx, store):
ctx['has'] = [
key for key, value in request.__class__.__dict__.items()
if isinstance(value, BaseField) and not request.attr_is_null(key)
]
score = 42 if request.is_admin else scoring.get_score(
store, request.phone, request.email, request.birthday, request.gender,
request.first_name, request.last_name)
return {"score": score}, OK
def test_on_connected_store_get_score(self, kwargs):
score = kwargs.pop('score')
kwargs['birthday'] = api.DateField.str_to_date(kwargs['birthday'])
self.store.cache_set('uid:9a423ca46b5c7d79f8d335405e273261', 13.7,
60 * 60)
self.store.cache_set('uid:99e176a6339c3ed7d753d610e2580f01', -0.9,
60 * 60)
self.assertAlmostEqual(scoring.get_score(self.store, **kwargs),
score,
delta=0.1)
def get_result(self, store):
if self.request.is_admin:
return {"score": 42}
return {
"score":
get_score(store, str(self.request.phone), str(self.request.email),
str(self.request.birthday), str(self.request.gender),
str(self.request.first_name),
str(self.request.last_name))
}
def get_result(self, is_admin, store):
if is_admin:
score = 42
else:
try:
score = get_score(store, self.phone.value, self.email.value, self.birthday.value, self.gender.value,
self.first_name.value, self.last_name.value)
except:
return {"message" : self.err_msg(INTERNAL_ERROR, {})}, INTERNAL_ERROR
return {"score": score}, OK
def get_result(self, is_admin, store):
if is_admin:
score = 42
else:
try:
store.set_mode('cache')
score = get_score(store.storage, self.phone.value, self.email.value, self.birthday.value, self.gender.value,
self.first_name.value, self.last_name.value)
except Exception as error:
return {"message" : self.err_msg(INTERNAL_ERROR, (), error.message)}, INTERNAL_ERROR
return {"score": score}, OK
