async def post_couriers(courier_list: Couriers):
db = Session()
courier_ids = []
courier_fail_ids = []
for courier in courier_list.data:
db_courier = CourierSchema(courier_id=courier.courier_id,
courier_type=courier.courier_type,
regions=courier.regions,
working_hours=courier.working_hours)
db.add(db_courier)
try:
db.commit()
except IntegrityError:
courier_fail_ids.append(courier.courier_id)
else:
db.refresh(db_courier)
courier_ids.append(courier.courier_id)
if len(courier_fail_ids) == 0:
return JSONResponse(
content={'couriers': [{
'id': c_id
} for c_id in courier_ids]},
status_code=status.HTTP_201_CREATED)
else:
return JSONResponse(content={
"validation_error": {
'couriers': [{
'id': c_id
} for c_id in courier_fail_ids]
}
},
status_code=status.HTTP_400_BAD_REQUEST)
def get_test_data(min_appt=5):
file_path = os.path.join(PRIVATE_DIR, 'vectors',
f'test_data_{min_appt}.json')
if os.path.exists(file_path):
with open(file_path, 'r') as f:
return json.load(f)
session = Session()
users = get_users(session, min_appt)
user_data = {}
for user in progressbar(users):
last_doctor, town_doctors, all_appts = get_last_doctor_with_all_in_town_with_all_appts(
session, user)
if last_doctor.id not in town_doctors:
continue
user_data[user] = {
'selected_doctor': last_doctor.id,
'suggested_doctors': town_doctors,
'all_appts': [appt.doctor_id for appt in all_appts],
}
with open(file_path, 'w') as f:
json.dump(user_data, f)
print('len ->', len(user_data))
return user_data
async def assign_post(courier_id: CourierID):
response_ids = []
default_response = JSONResponse(status_code=status.HTTP_400_BAD_REQUEST)
db = Session()
courier_from_db = db.query(CourierSchema).get(courier_id.courier_id)
if not courier_from_db:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="Courier not found")
query = db.query(OrderSchema).filter(
and_(OrderSchema.region.in_(courier_from_db.regions)),
(OrderSchema.weight <= courier_from_db.courier_type.weight())).all()
if not query:
return default_response
for order in query:
if check_courier_time_for_order(courier_from_db.working_hours,
order.delivery_hours):
order.courier_id_assigned = courier_from_db.courier_id
response_ids.append(order.order_id)
if response_ids:
db.commit()
return JSONResponse(status_code=status.HTTP_200_OK,
content={
'orders': [{
'id': id_
} for id_ in response_ids],
'assign_time':
datetime.now().isoformat()[:-4] + 'Z'
})
else:
return default_response
async def post_orders(order_list: Orders):
db = Session()
order_ids = []
order_fail_ids = []
for order in order_list.data:
db_order = OrderSchema(order_id=order.order_id,
weight=order.weight,
region=order.region,
delivery_hours=order.delivery_hours)
db.add(db_order)
try:
db.commit()
except IntegrityError:
order_fail_ids.append(order.order_id)
else:
db.refresh(db_order)
order_ids.append(order.order_id)
if len(order_fail_ids) == 0:
return JSONResponse(
content={'couriers': [{
'id': c_id
} for c_id in order_ids]},
status_code=status.HTTP_201_CREATED)
else:
return JSONResponse(content={
"validation_error": {
'couriers': [{
'id': c_id
} for c_id in order_fail_ids]
}
},
status_code=status.HTTP_400_BAD_REQUEST)
def get_biggest_data():
file_path = os.path.join(PRIVATE_DIR, 'vectors', f'test_full_data.json')
if os.path.exists(file_path):
with open(file_path, 'r') as f:
return json.load(f)
session = Session()
appts = get_all_last_appointment(session)
user_data = {}
for appt in progressbar(appts, max_value=appts.count()):
user_id, appt_id, spec_id, town_id, last_doctor_id = appt
town_doctors = get_town_doctor_list(session, town_id, spec_id)
if last_doctor_id not in town_doctors:
continue
user_data[user_id] = {
'selected_doctor': last_doctor_id,
'suggested_doctors': town_doctors,
'all_appts': [],
}
with open(file_path, 'w') as f:
json.dump(user_data, f)
print('len ->', len(user_data))
return user_data
async def get_courier(courier_id: int):
db = Session()
query = db.query(CourierSchema).get(courier_id)
# TODO дополнительные поля и подсчет рейтинга!
if not query:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
detail="Courier not found")
return JSONResponse(query.to_dict())
def today_orders_import(ctx):
"""
read orders from url and write new today orders into database
"""
url = 'https://online.moysklad.ru/api/remap/1.1/entity/customerorder'
login = '******'
password = '******'
resp = get(url, auth=HTTPBasicAuth(login, password))
get_orders = resp.json()
session_orders = Session()
session_clients = Session()
if settings.debug:
today = date(2019, 2, 15)
else:
today = datetime.today().date()
for i in get_orders['rows']:
if datetime.strptime(i['moment'], "%Y-%m-%d %H:%M:%S").date() == today:
if not session_orders.query(DenysOrders).filter(
DenysOrders.id == i['id']).all():
client_data = get(i['agent']['meta']['href'],
auth=HTTPBasicAuth(login, password)).json()
if not session_clients.query(DenysClients).filter(
DenysClients.id == client_data['id']).all():
session_clients.add(
DenysClients(
id=client_data['id'],
name=client_data['name'],
))
session_orders.add(
DenysOrders(
id=i['id'],
name=i['name'],
# description =
moment=i['moment'],
sum=i['sum'],
counterparty_id=client_data['id'],
))
session_clients.commit()
session_orders.commit()
def session_scope(self):
session = Session()
try:
yield session
session.commit()
except:
session.rollback()
raise
finally:
session.close()
def __init__(self):
"""
Create the Analyzer object
"""
self.db = Session()
# TODO there must be a better way of reading the config file path!
analyzers_dir = os.path.dirname(__file__)
self.config = configparser.ConfigParser()
self.config.read(
os.path.abspath(
os.path.join(analyzers_dir, '..', 'metrics',
'thresholds.conf')))
def __init__(self, name: str, players: List, session=Session()):
if type(players) is not list or len(players) < 1:
raise MissingRequiredParameterError("Players", self.__class__.name)
if name is None:
raise MissingRequiredParameterError("Name", self.__class__.name)
max_players_no = self.get_max_players_no(session)
if len(players) > max_players_no:
raise ValueError(
f"Number of players exceeds the limit of {max_players_no}!")
self.players = players
self.name = name
async def complete_post(order: OrderDone):
db = Session()
courier_from_db = db.query(CourierSchema).get(order.courier_id)
order_from_db = db.query(OrderSchema).get(order.order_id)
if not courier_from_db or not order_from_db or courier_from_db.courier_id != order.courier_id:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="Wrong courier or order id")
# TODO count rating
db.delete(order_from_db)
db.commit()
return JSONResponse(status_code=status.HTTP_200_OK,
content={'order_id': order.order_id})
async def patch_courier(courier_id: int, data: PatchCourier):
db = Session()
query = db.query(CourierSchema).get(courier_id)
if not query:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
detail="Courier not found")
else:
if data.courier_type and data.regions and data.working_hours:
query.regions = data.regions
db.commit()
return JSONResponse(query.to_dict(),
status_code=status.HTTP_200_OK)
else:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="Wrong fields")
def create(self):
session = Session()
data = pd.DataFrame.from_records(session.query(Doctor).order_by(
Doctor.id).all(),
columns=Doctor._fields)
doctor_stats = data.iloc[:, [0, 1, 2]]
matrix = MinMaxScaler().fit_transform(data.iloc[:, 3:])
doctors = {}
progress = progressbar.ProgressBar(max_value=data.shape[0])
for stat, values in zip(doctor_stats.iterrows(), matrix):
doctors[str(int(stat[1][0]))] = values.tolist()
progress.next()
self._vectors = doctors
def create_top_one_train_data(
min_appts: int) -> Tuple[pd.DataFrame, pd.DataFrame]:
session = Session()
all_users = get_all_appointment_users(session, min_appts)
doctor_vectors = DoctorVector()
doctor_vectors.load()
test = []
train = []
for user in progressbar(all_users):
# add test data
last_appt, test_appt = get_two_last_appointment(session, user)
test_doctor_model = session.query(Doctor).filter(
Doctor.id == test_appt.doctor_id).first()
test_doctors = get_town_doctor_list(session, test_doctor_model.town_id,
test_appt.spec_id)
test_appt_id = test_appt.id
for doctor in test_doctors[:100]:
if doctor == test_doctor_model.id:
continue
test.append([0, test_appt_id, *doctor_vectors[doctor]])
test.append([1, test_appt_id, *doctor_vectors[test_doctor_model.id]])
# add train data
all_user_appts = get_all_appointments(
session, user, [last_appt.doctor_id, test_appt.doctor_id])
for appt in all_user_appts:
appt_id = appt.id
train.append([1, appt_id, *doctor_vectors[appt.doctor_id]])
train_doctor_model = session.query(Doctor).filter(
Doctor.id == appt.doctor_id).first()
train_town_doctors = get_town_doctor_list(
session, train_doctor_model.town_id, appt.spec_id)
for doctor in train_town_doctors[:100]:
if doctor == train_doctor_model.id:
continue
train.append([0, appt_id, *doctor_vectors[doctor]])
test_df = pd.DataFrame(test)
train_df = pd.DataFrame(train)
return test_df, train_df
def create(self):
doctor_vectors = DoctorVector()
doctor_vectors.load()
session = Session()
appts = {}
for appt in session.query(Appointment.user_id,
Appointment.doctor_id).all():
appts.setdefault(str(appt.user_id), []).append(int(appt.doctor_id))
users_vectors = {}
progress = progressbar.ProgressBar(max_value=len(appts))
for user_id, doctor_ids in appts.items():
vectors = [doctor_vectors[doctor_id] for doctor_id in doctor_ids]
users_vectors[user_id] = np.sum(vectors, axis=0).tolist()
progress.update(progress.value + 1)
self._vectors = users_vectors
def excel_read(ctx):
"""
read from excel file and fill the database
"""
session = Session()
session.query(DenysOrders).delete()
session.query(DenysClients).delete()
loc = '../task/ПримерМСКонтрагентыSQLAzure2.xlsx'
wb = xlrd.open_workbook(loc)
orders_sheet = wb.sheet_by_index(0)
counterparty_sheet = wb.sheet_by_index(1)
clients_list = []
for i in range(1, counterparty_sheet.nrows):
values = counterparty_sheet.row_values(i)
clients_list.append(DenysClients(
id=values[0],
name=values[1],
))
session.add_all(clients_list)
session.commit()
orders_list = []
for i in range(1, orders_sheet.nrows):
values = orders_sheet.row_values(i)
orders_list.append(
DenysOrders(
id=values[0],
name=values[1],
description=values[2],
moment=values[3],
sum=values[4],
counterparty_id=values[5],
))
session.add_all(orders_list)
session.commit()
def get_basic_metrics(self):
"""
Get a set of basic metrics related to the Spark application.
:return: dict (metric_name: value)
"""
db = Session()
basic_metrics = {}
runtime = self.duration / 1000.0 # seconds
cpu_time = cast_or_none(
db.query(func.sum(StageEntity.executor_cpu_time) /
1.0e9).filter(StageEntity.app_id == self.app_id).scalar(),
float) # seconds
total_tasks_time = cast_or_none(
db.query(func.sum(TaskEntity.duration) / 1000.0).filter(
and_(TaskEntity.stage_key == StageEntity.stage_key,
StageEntity.app_id == self.app_id)).scalar(), float)
total_gc_time = cast_or_none(
db.query(func.sum(ExecutorEntity.total_gc_time) / 1.0e3).filter(
ExecutorEntity.app_id == self.app_id).scalar(),
float) # seconds
basic_metrics["Duration"] = fmt_time(runtime) # seconds
basic_metrics["CPU Time"] = fmt_time(cpu_time) # seconds
basic_metrics["Total Tasks Time"] = fmt_time(total_tasks_time)
basic_metrics["Spark Mode"] = self.mode
basic_metrics["Jobs Number"] = db.query(func.count(
JobEntity.job_id)).filter(
JobEntity.app_id == self.app_id).scalar()
basic_metrics["Stages Number"] = db.query(
func.count(StageEntity.stage_id)).filter(
StageEntity.app_id == self.app_id).scalar()
basic_metrics["Tasks Number"] = cast_or_none(
db.query(func.sum(StageEntity.num_tasks)).filter(
StageEntity.app_id == self.app_id).scalar(), int)
basic_metrics["Total GC Time"] = fmt_time(total_gc_time) # seconds
return basic_metrics
def __init__(self):
Base.metadata.create_all(engine)
self.session = Session()
self.__downloader = PrometeyDownloader()
self.__amazon = PrometeyAmazon(config['aws'])
def __init__(self, user_id, quote_id, reaction, **kwargs):
self.user = user_id
self.quote = quote_id
if reaction not in REACTIONS_OPTIONS:
raise ModelError(f'reaction must be one of {REACTIONS_OPTIONS}')
self.reaction = reaction
self.seen_date = kwargs.get('creation_date', datetime.now().date())
def __str__(self):
return f'Reaction[id={self.id}, seen_date={self.seen_date}, reaction={self.reaction}, user={self.user}, quote_id={self.quote}]'
if __name__ == '__main__':
Base.metadata.create_all(engine)
session = Session()
user = User('3649028588457703', 'DAILY')
session.add(user)
quote = Quote(
"If you want to achieve greatness stop asking for permission.",
"Anonymous")
session.add(quote)
session.commit()
user_quote = Reaction('3649028588457703', quote.id, 'LIKE')
session.add(user_quote)
session.commit()
session.close()
print("=== Now querying data ===")
session = Session()
users = session.query(User).all()
for user in users:
def __init__(self):
Base.metadata.create_all(engine)
self.session = Session()
def init_db():
Base.metadata.create_all(engine)
global session
session = Session()
def get_max_players_no(cls, session=Session()) -> int:
value = get_class_attribute(cls, "max_players_no", session)
if value is None:
return 8
return int(value)
def set_max_players_no(cls, value: int, session=Session()) -> None:
return set_class_attribute(cls, "max_players_no", value, session)
def prepare_database():
Base.metadata.create_all(engine)
session = Session()
commit_and_close(session)
def main():
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
models.Group.set_max_players_no(5)
session = Session()
address_1 = models.Address("city", "postcode", "street", 2)
address2 = models.Address("city", "postcode", "street", 1)
person = models.Person(first_name="Jan", last_name="Kowalski")
owner_1 = models.EscapeRoomOwnerPerson(username="******",
password="******",
address=address2,
er_owner_person=person)
owner_2 = models.EscapeRoomOwnerCompany(username="******",
password="******",
name="Escapers Inc.",
establishment_date=date(
2020, 1, 1),
address=address_1)
owner_3 = models.EscapeRoomOwnerCompany(username="******",
password="******",
name="Crazytown",
establishment_date=date(
2020, 1, 1),
address=address_1)
escape_room1 = models.FixedPriceEscapeRoom(
name="W krainie zła",
opening_date=date(2020, 5, 1),
category=models.EscapeRoomCategory.THRILLER,
min_players_no=1,
max_players_no=5,
price=80,
owner=owner_1)
escape_room2 = models.VariablePriceEscapeRoom(
name="Dziki zachód",
opening_date=date(2020, 5, 1),
category=models.EscapeRoomCategory.HORROR,
min_players_no=1,
max_players_no=5,
max_price=15,
price=80,
owner=owner_3)
escape_room3 = models.WeekendPriceEscapeRoom(
name="Wszyscy ludzie prezydenta",
opening_date=date(2020, 5, 1),
category=models.EscapeRoomCategory.CRIME,
min_players_no=1,
max_players_no=5,
weekend_price=90,
price=80,
owner=owner_2)
escape_room4 = models.FixedPriceEscapeRoom(
name="Uprowadzeni przez wampira",
opening_date=date(2019, 1, 1),
closing_date=date(2020, 5, 3),
category=models.EscapeRoomCategory.THRILLER,
min_players_no=1,
max_players_no=5,
price=80,
owner=owner_2)
escape_room5 = models.FixedPriceEscapeRoom(
name="Rycerze",
opening_date=date(2020, 5, 1),
category=models.EscapeRoomCategory.HISTORY,
min_players_no=1,
max_players_no=5,
price=80,
owner=owner_2)
escape_room6 = models.FixedPriceEscapeRoom(
name="Subnautica",
opening_date=date(2020, 5, 1),
category=models.EscapeRoomCategory.ADVENTURE,
min_players_no=1,
max_players_no=5,
price=80,
owner=owner_1)
group1 = create_group()
player1 = models.Player(username="******",
password="******",
person=models.Person(first_name="Sandra",
last_name="Rawicz"))
player2 = models.Player(username="******",
password="******",
person=models.Person(first_name="Anna",
last_name="Barańska"))
player3 = models.Player(username="******",
password="******",
person=models.Person(first_name="Jan",
last_name="Nowacki"))
group2 = models.Group(name="Ja i mój chłopak", players=[player1])
group3 = models.Group(name="Znajomi z pracy", players=[player1, player2])
visit1 = models.Visit(group=group2,
escape_room=escape_room2,
visit_date=date(2020, 6, 19),
duration=61,
rating=3)
visit2 = models.Visit(group=group3,
escape_room=escape_room6,
visit_date=date(2020, 6, 16),
duration=50,
rating=5)
recommendation1 = models.Recommendation(player=player1,
escape_room=escape_room1,
expected_rating=4)
recommendation2 = models.Recommendation(player=player2,
escape_room=escape_room2,
expected_rating=5)
recommendation3 = models.Recommendation(player=player1,
escape_room=escape_room3,
expected_rating=3)
objects = [
escape_room1, escape_room2, escape_room3, escape_room4, escape_room5,
escape_room6, player3, group1, group2, group3, visit1, visit2,
recommendation1, recommendation2, recommendation3
]
session.add(player1)
try:
session.commit()
except Exception as ex:
print(ex)
for obj in objects:
session.add(obj)
try:
session.commit()
except Exception as ex:
print(ex)
print(person.player)
print(person.er_owner)
print(escape_room5.get_rating())
