def process_insert_row(job_id, resp_row, treatment, overwrite=False):
"""
Insert a new row for the proposer assuming no model is available
"""
app.logger.debug("process_insert_row")
resp_row = dict(resp_row)
_, features_dict = get_features(job_id,
resp_worker_id=resp_row[WORKER_KEY],
treatment=treatment)
resp_row = dict(resp_row)
resp_row.update(features_dict)
df = pd.DataFrame(data=[resp_row])
df[STATUS_KEY] = RowState.JUDGEABLE
df[LAST_MODIFIED_KEY] = time.time()
df[WORKER_KEY] = None
df["resp_worker_id"] = resp_row[WORKER_KEY]
table = get_table(BASE, job_id=job_id, schema="data", treatment=treatment)
con = get_db("DATA")
insert(df,
table,
con=con,
overwrite=overwrite,
unique_fields=["resp_worker_id"])
app.logger.debug("process_insert_row - done")
def save_worker_id(job_id, worker_id, worker_code, assignment_id, base=None):
"""
Save the given information in a general table
:param job_id:
:param worker_id:
:param worker_code:
:assignment_id:
"""
app.logger.debug(
f"save_worker_id: job_id: {job_id}, worker_id: {worker_id}")
if base is None:
base = "txx"
table_all = get_table("txx", "all", schema=None)
try:
insert(pd.DataFrame(data=[{
"job_id": job_id,
"worker_id": worker_id,
"worker_code": worker_code,
"assignment_id": assignment_id
}]),
table=table_all,
unique_fields=["worker_id"])
except Exception as err:
app.log_exception(err)
def process_insert_row_dss(job_id, resp_row, treatment, overwrite=False):
"""
Insert a new row for the proposer with the ai predicted min_offer
"""
app.logger.debug("process_insert_row_dss")
ENABLED_FAKE_MODEL_KEY = f"{treatment.upper()}_FAKE_MODEL"
MODEL_KEY = f"{TREATMENTS_MODEL_REFS[treatment.upper()]}_MODEL"
FAKE_MODEL_TYPES = [WEAK_FAKE_MODEL, STRONG_FAKE_MODEL]
model_type = None
ai_offer = 0
features, features_dict = get_features(job_id,
resp_worker_id=resp_row[WORKER_KEY],
treatment=treatment)
resp_row = dict(resp_row)
resp_row.update(features_dict)
df = pd.DataFrame(data=[resp_row])
df[STATUS_KEY] = RowState.JUDGEABLE
df[LAST_MODIFIED_KEY] = time.time()
df[WORKER_KEY] = None
df["resp_worker_id"] = resp_row[WORKER_KEY]
df["ai_offer"] = ai_offer
df["model_type"] = model_type
table = get_table(BASE, job_id=job_id, schema="data", treatment=treatment)
con = get_db("DATA")
insert(df,
table,
con=con,
overwrite=overwrite,
unique_fields=["resp_worker_id"])
with con:
rowid = con.execute(
f"SELECT {PK_KEY} FROM {table} where resp_worker_id=?",
(resp_row[WORKER_KEY], )).fetchone()[PK_KEY]
# if true, fake models should be used for this treatment
if app.config[ENABLED_FAKE_MODEL_KEY]:
if rowid is not None:
model_type = FAKE_MODEL_TYPES[rowid % len(FAKE_MODEL_TYPES)]
else:
model_type = REAL_MODEL
else:
model_type = REAL_MODEL
if model_type == WEAK_FAKE_MODEL:
ai_offer = predict_weak(resp_row["min_offer"])
elif model_type == STRONG_FAKE_MODEL:
ai_offer = predict_strong(resp_row["min_offer"])
else:
# Models predict a vector
ai_offer = app.config[MODEL_KEY].predict(features)[0]
ai_offer = int(ai_offer)
with con:
update(
sql=f"UPDATE {table} SET ai_offer=?, model_type=? where rowid=?",
args=(ai_offer, model_type, rowid),
con=con)
app.logger.debug("process_insert_row_dss - done MODEL_TYPE: " +
str(rowid % len(FAKE_MODEL_TYPES)) + " " + str(rowid))
def save_prop_result2db(con,
proposal_result,
job_id,
overwrite=False,
treatment=None):
table = get_table(BASE,
job_id=job_id,
schema="result",
treatment=treatment)
df = pd.DataFrame(data=[proposal_result])
insert(df, table=table, con=con, overwrite=overwrite)
def update_job(con, job_id, job_config, table="jobs"):
if not table_exists(con, table):
insert(pd.DataFrame(data=[job_config]), table=table, con=con)
else:
with con:
check = con.execute(f"SELECT job_id from jobs where job_id==?",
(job_id, )).fetchone()
if check:
update(
f"UPDATE {table} SET api_key=?, base_code=?, expected_judgments=?, payment_max_cents=?",
args=(job_config['api_key'], job_config['base_code'],
job_config['expected_judgments'],
job_config['payment_max_cents']),
con=con)
else:
insert(pd.DataFrame(data=[job_config]), table=table, con=con)
def save_result2db(table,
response_result,
overwrite=False,
unique_fields=None):
"""
:param table: (str)
:param response_result: (dict)
:param overwrite: (bool)
:param unique_fields: (str|list)
"""
df = pd.DataFrame(data=[response_result])
insert(df,
table=table,
con=get_db("RESULT"),
overwrite=overwrite,
unique_fields=unique_fields)
def increase_worker_bonus(job_id, worker_id, bonus_cents, con=None):
"""
:param job_id:
:param worker_id:
:param bonus_cents: (int)
:param con:
"""
app.logger.debug(
f"increase_worker_bonus - job_id: {job_id}, worker_id: {worker_id}, bonus_cents: {bonus_cents}"
)
if con is None:
con = get_db("DB")
row_data = {
'job_id': job_id,
'worker_id': worker_id,
'timestamp': str(datetime.datetime.now()),
'bonus_cents': bonus_cents,
'paid_bonus_cents': 0
}
table = _get_payment_table(job_id)
worker_row_exists = False
if table_exists(con, table):
with con:
row = con.execute(
f'select *, rowid from {table} WHERE job_id==? and worker_id==?',
(job_id, worker_id)).fetchone()
if row:
worker_row_exists = True
row_data["bonus_cents"] += row["bonus_cents"]
row_data["paid_bonus_cents"] += row["paid_bonus_cents"]
update(
f"UPDATE {table} SET bonus_cents=?, paid_bonus_cents=? WHERE rowid=?",
(row_data["bonus_cents"], row_data["paid_bonus_cents"],
row["rowid"]),
con=con)
if not worker_row_exists:
app.logger.debug(
f"increase_worker_bonus: {job_id}, {worker_id}, {bonus_cents}")
df = pd.DataFrame(data=[row_data])
insert(df, table, con, unique_fields=["worker_id"])
con.commit()