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