def getAllUsers():
try:
users = {}
for useri in cache.scan_iter("user*"):
if useri:
user = {}
useri = useri.decode('utf-8')
imps = getUserImps(useri)
reqs = getUserReqs(useri)
key = useri[5:]
user = {
key: {
"user-name": key,
"impressions": imps,
"ad-requests": reqs
}
}
users.update(user)
elif useri is None:
break
if users:
return users
elif not users:
return -1
except Exception as e:
return errors.error_response(412, e)
def saveAdReqs(userName,sdk):
try:
user.saveUserReqs(userName)
sdkModel.saveSdkReqs(sdk)
return True
except Exception as e:
return errors.error_response(e)
def getAllSdks():
try:
sdks = {}
for sdki in cache.scan_iter("sdk*"):
sdk = {}
sdki = sdki.decode('utf-8')
imps = getSdkImps(sdki)
reqs = getSdkReqs(sdki)
key = sdki[4:]
sdk = {
key: {
"sdk-version": key,
"impressions": imps,
"ad-requests": reqs
}
}
sdks.update(sdk)
if sdks:
return sdks
elif not sdks:
return -1
except Exception as e:
return errors.error_response(412, e)
def saveImpression(userName,sdk):
try:
user.saveUserImps(userName)
sdkModel.saveSdkImps(sdk)
return True
except Exception as e:
return errors.error_response(e)
def get_book_api(user_id, book_id):
user = User.query.get_or_404(user_id)
book = Book.query.filter_by(owner_id=user_id, id=book_id).first()
if book is None:
return error_response(404, "book {} not found".format(book_id))
return jsonify(book.to_dict())
def saveSdkReqs(sdk):
try:
if cache.exists('sdk:' + sdk):
cache.hincrby('sdk:' + sdk, 'requests', 1)
elif not cache.exists('sdk:' + sdk):
cache.hincrby('sdk:' + sdk, 'requests', 1)
cache.hset('sdk:' + sdk, 'impressions', 0)
except Exception as e:
return errors.error_response(412, str(e))
def saveUserImps(user):
try:
if cache.exists('user:'******'user:'******'impressions', 1)
elif not cache.exists('user:'******'user:'******'impressions', 1)
cache.hincrby('user:'******'requests', 0)
except Exception as e:
return errors.error_response(412, e)
def sendRequest():
try:
url = "https://6u3td6zfza.execute-api.us-east-2.amazonaws.com/prod/ad/vast"
r = {}
r = requests.get(url)
return r.content.decode('utf8')
except requests.exceptions.ConnectionError as e:
if not r:
return errors.error_response(e.errno,e.strerror)
def handle_file_upload(file_storage: FileStorage, upload_type: str):
filename, file_extension = os.path.splitext(file_storage.filename)
file_uuid = f'{str(uuid.uuid4())}_{filename}'
log.info(f'Save file {file_uuid}')
original_filename = config.custom_input_file(
f'{file_uuid}{file_extension}')
csv_filename = config.custom_input_file(f'{file_uuid}.csv')
file_storage.save(original_filename)
log.info(f'Extract {upload_type}')
data = None
detected_language = None
try:
if upload_type == CSV_FILE:
data = pd.read_csv(original_filename)
elif upload_type == TXT_FILE:
data = convert_txt_to_csv(original_filename)
elif upload_type == WHATS_APP_TXT_FILE:
data = convert_whats_app_to_csv(original_filename)
elif upload_type == ZIP_FILE:
data = DirectoryAnalytics(original_filename).pandas_data
else:
error_response(f"{file_extension} not supported yet")
sample_text = " ".join(map(str, data.iloc[0].tolist()))
detected_language = iso639.to_name(detect(sample_text)).lower()
except Exception as e:
upload_error_handler(e, original_filename, upload_type)
if upload_type != CSV_FILE:
log.info(f'Remove file: {original_filename}')
os.remove(original_filename)
data.to_csv(csv_filename)
return {
'cols': [col for col in data.columns],
'filename': file_uuid,
'language': detected_language,
'recommendationSet': calculate_n_clusters_by_category(data.shape[0])
}
def get_elections():
"""
Get all the election cycles from 2019-2020
:return: list or set of JSON objects containing individual election cycle information
"""
try:
election_shape = redis.getAnyShape("elections")
if not election_shape:
return empty_response("Elections")
return jsonify(election_shape)
except Exception as error:
return error_response(f"{error}")
def get_metadata():
"""
Get
:return: JSON containing metadata
"""
try:
metadata_shape = redis.getAnyShape("metadata")
if not metadata_shape:
return empty_response("Metadata")
return jsonify(metadata_shape)
except Exception as error:
return error_response(f"{error}")
def get_referendums():
"""
Get all referendums from current election cycle
:return: JSON containing referendum data
"""
try:
referendums_shape = redis.getAnyShape("referendums")
if not referendums_shape:
return empty_response("Referendums")
return jsonify(referendums_shape)
except Exception as error:
return error_response(f"{error}")
def create_candidate():
data = request.get_json()
if "name" not in data:
return error_response(400, "Name not found")
candidate_name = data["name"]
candidate = Candidate.query.filter_by(name=candidate_name).first()
status_code = 200
if not candidate:
candidate = Candidate(name=candidate_name)
db.session.add(candidate)
db.session.commit()
status_code = 201
return jsonify(candidate.serialize()), status_code
def get_committees(serve_fake=True):
"""
Get all the committees from the current election period
:return: list or set of JSON objects containing individual candidate information
"""
if serve_fake:
return jsonify({"Committees": fake_data.get_committees_shape()})
try:
response = redis.getAnyShape("Committees")
if not response:
return empty_response("Committees")
return jsonify({"Committees": json.loads(response)})
except Exception as error:
return error_response(f"{error}")
def __init__(self, settings):
data_source = settings['city']
if data_source not in [
'amsterdam', 'athens', 'barcelona', 'berlin', 'bologna',
'dublin', 'geneva', 'hongkong', 'westernaustralia'
]:
error_response(f'{data_source} does not exist')
CsvDataHandler.__init__(self, f'AirBnBDB{data_source}',
f'{data_source}_listings_details.csv')
self.HAS_MULTIPLE_DATA_SOURCES = True
self.DATA_SOURCE = data_source
self.PRE_LOAD_UUID = f'AirBnB-Demo-{data_source}'
self.df = self.df[:4_000]
self.saved_item_to_cluster = [
i + j + k + l for i, j, k, l in zip(
self.clean_up_df_text('description'),
self.clean_up_df_text('space'),
self.clean_up_df_text('neighborhood_overview'),
self.clean_up_df_text('transit'))
]
def get_total_contributions(serve_fake=True):
"""
Query redis to get the total amount of monies spent
:return: int representing the total for (either all time or current election)
"""
if serve_fake:
return jsonify({"TotalContributions": 100000})
try:
response = redis.getAnyShape("Total Contributions")
if not response:
return empty_response("TotalContributions")
return jsonify({"TotalContributions": json.loads(response)})
except Exception as error:
return error_response(f"{error}")
def GetStats():
try:
if "filterType" in request.args:
if request.args["filterType"] == 'user':
users = user.getAllUsers()
if users != -1:
for i in users:
imps = users[i]["impressions"]
reqs = users[i]["ad-requests"]
if int(reqs) != 0:
fillRate = imps / reqs
users[i].update({"fill-rate":float(fillRate)})
elif int(reqs) == 0:
users.pop(i)
return app.make_response(rv=jsonify(users))
elif users == -1:
return errors.error_response(412,"no users to calculate")
elif request.args["filterType"] == "sdk":
sdks = sdkModel.getAllSdks()
if sdks:
for i in sdks:
imps = sdks[i]["impressions"]
reqs = sdks[i]["ad-requests"]
if int(reqs) != 0:
fillRate = int(imps) / int(reqs)
sdks[i].update({"fill-rate":float(fillRate)})
elif int(reqs) == 0:
sdks.pop(i)
return app.make_response(rv=jsonify(sdks))
elif sdks == -1:
errors.error_response(412,"no sdks to calculate")
except Exception as e:
return errors.error_response(412,e)
def GetAd():
try:
if len(request.args) == 5 and 'sdk' in request.args and "user" in request.args:
req = sendRequest()
if req:# XML in a VAST format in a json format
if saveAdReqs(request.args['user'],request.args['sdk']):
return app.make_response(rv = req)
elif not req:
return errors.error_response(412,"No XML VAST Retrived")
elif len(request.args) != 5 or not "user" in request.args or not "sdk" in request.args:
return errors.bad_request("wrong input in request or missing")
except Exception as e:
return errors.bad_request(str(e))
def upload_error_handler(e, original_filename, upload_type):
log.error(f'Remove file due to an error: {original_filename}')
os.remove(original_filename)
log.error('An exception occurred: %r', e)
if upload_type == CSV_FILE:
error_response(f"Currenty only ','-separated files are supported")
if upload_type == ZIP_FILE:
error_response(f"Zip is empty. It only supports: {FILTER_OPTION_LIST}")
error_response(f"Wrong data format")
def get_candidates(serve_fake=False):
"""
Get all the candidates from the current election period or
a specific candidate
:param candidate_id: unique identifier associated with each candidate {election-title;cand-name;election-date}
:type candidate_id: string
:return: data on all candidates or for one specific candidate
:rtype: JSON
"""
try:
candidate_shape = redis.getAnyShape("candidates")
if not candidate_shape:
return empty_response("Candidates")
return jsonify(candidate_shape)
except Exception as error:
return error_response(f"{error}")
def token_auth_error():
return error_response(401)
def basic_auth_error():
return error_response(401)
def get_by_candidate(candidate_name):
candidate = Candidate.query.filter_by(name=candidate_name).first()
if not candidate:
return error_response(404, "Candidate not found")
return jsonify(candidate.serialize()), 200
def token_auth_error():
return error_response(401, 'Неправильные креденшиалы')
def not_found():
return error_response(404, 'Not found')
class FizzBuzzResponse(BaseModel):
passed: bool = True
message: str = ''
@app.exception_handler(ApiError)
async def api_error_handler(request, err: ApiError):
raise HTTPException(status_code=err.status_code,
detail=f'{err.detail}\n{err.reason}')
@app.post("/check_fizzbuzz",
response_model=FizzBuzzRequest,
responses=error_response([
DontSetDummyParameter, InvalidFizzBuzzInput, WrongFizzBuzzAnswer
]))
def check_fizzbuzz(req: FizzBuzzRequest):
if req.dummy:
# 実際は validator でやると綺麗
raise DontSetDummyParameter()
try:
expected = fizzbuzz(req.input)
except ValueError:
# 実際は validator でやると綺麗
raise InvalidFizzBuzzInput(reason=f'{req.input} is invalid range.')
if expected != req.answer:
raise WrongFizzBuzzAnswer(
reason=f'`{req.answer}` is wrong. Expected: `{expected}`')
return FizzBuzzResponse(message='Good!')
