def set_precision(self):
q = u"""select count(input_id) from accuracy_from_mturk as accuracy, pub where accuracy.input_id=pub.id and response_is_oa and answer_error='{}' and answer_green_box_url != '{}'"""
if self.no_rg_or_academia:
q += " and not (answer_green_box_url ilike '%researchgate%' or answer_green_box_url ilike '%academia.edu%')"
q += self.q_suffix_relevant_set()
precision_numerator = get_sql_answer(db, q)
q = u"""select count(input_id) from accuracy_from_mturk as accuracy, pub where accuracy.input_id=pub.id and response_is_oa and answer_error='{}'"""
q += self.q_suffix_relevant_set()
precision_denominator = get_sql_answer(db, q)
try:
self.precision = float(precision_numerator)/precision_denominator
except ZeroDivisionError:
return float('inf')
def package_create(jusp_id, institution_id, package_type):
jisc_package_id = u"package-jiscels{}".format(jusp_id)
package_id = u"package-n8els_{}_{}".format(jusp_id,
package_type.replace(" ", ""))
package_name = u"Elsevier n8 ({})".format(package_type)
scenario_id = u"scenario-n8els_{}_{}".format(jusp_id,
package_type.replace(" ", ""))
scenario_name = u"n8 ({})".format(package_type)
my_package = Package.query.get(package_id)
if not my_package:
print u"package {} doesn't exist, making".format(package_id)
my_package = Package(package_id=package_id,
publisher="Elsevier",
package_name=package_name,
created=datetime.datetime.utcnow().isoformat(),
institution_id=institution_id,
is_demo=False,
currency="GBP")
db.session.add(my_package)
print my_package
safe_commit(db)
if package_type == "own pta":
copy_into_n8_package(old_package_id=jisc_package_id,
new_package_id=package_id,
copy_perpetual_access=True)
elif package_type == "group pta":
copy_into_n8_package(old_package_id=jisc_package_id,
new_package_id=package_id,
copy_perpetual_access=False)
elif package_type == "uk pta":
copy_into_n8_package(old_package_id=jisc_package_id,
new_package_id=package_id,
copy_perpetual_access=False)
my_scenario = SavedScenario.query.get(scenario_id)
if not my_scenario:
print u"scenario {} doesn't exist, making".format(scenario_id)
my_scenario = SavedScenario(False, scenario_id, None)
my_scenario.package_id = package_id
my_scenario.created = datetime.datetime.utcnow().isoformat()
db.session.add(my_scenario)
safe_commit(db)
print "updating settings, including big deal cost from jisc package"
big_deal_price = get_sql_answer(
db,
"select big_deal_cost from jump_account_package where package_id = '{}';"
.format(jisc_package_id))
dict_to_save = my_scenario.to_dict_saved_from_db()
dict_to_save["name"] = scenario_name
dict_to_save["configs"]["cost_bigdeal"] = big_deal_price
dict_to_save["configs"]["cost_bigdeal_increase"] = 2
dict_to_save["configs"]["include_social_networks"] = True # set to true
dict_to_save["configs"]["weight_authorship"] = 0 # 100
dict_to_save["configs"]["weight_citation"] = 0 # 10
save_raw_scenario_to_db(scenario_id, dict_to_save, None)
def display_doi(self):
if hasattr(self, "doi"):
return self.doi
for other_id in self.pub_other_ids:
if other_id.source == "doi":
return other_id.other_id
q = "select doi from dois_pmid_lookup where pmid = {}::text".format(
self.pmid)
doi = get_sql_answer(db, q)
return doi
def number_unfinished(self, job_type):
num = get_sql_answer(
db, "select count(*) from {} where finished is null".format(
self.table_name(job_type)))
return num
def number_waiting_on_queue(self, job_type):
num = get_sql_answer(
db, "select count(*) from {} where started is null".format(
self.table_name(job_type)))
return num
def number_total_on_queue(self, job_type):
num = get_sql_answer(
db, "select count(*) from {}".format(self.table_name(job_type)))
return num
def get_parent_consortium_package_id(package_id):
q = """select consortium_package_id from jump_account_package where package_id = '{}'""".format(
package_id)
return get_sql_answer(db, q)
def set_n(self):
q = u"""select count(id) from accuracy_from_mturk as accuracy, pub where accuracy.input_id=pub.id and answer_error='{}'"""
q += self.q_suffix_relevant_set()
self.n = get_sql_answer(db, q)
def number_unfinished(job_type):
num = get_sql_answer(db, "select count(*) from {} where finished is null".format(table_name(job_type)))
return num
def number_waiting_on_queue(job_type):
num = get_sql_answer(db, "select count(*) from {} where started is null".format(table_name(job_type)))
return num
def number_total_on_queue(job_type):
num = get_sql_answer(db, "select count(*) from {}".format(table_name(job_type)))
return num
def add_ror(ror_id, institution_id):
logger.info(u"adding ROR IDs, if needed")
if not db.session.query(RorId).filter(
RorId.institution_id == institution_id, RorId.ror_id
== ror_id).all():
db.session.add(RorId(institution_id=institution_id, ror_id=ror_id))
logger.info(u" adding ROR ID {} for {}".format(
ror_id, institution_id))
else:
logger.info(u" ROR ID already there")
db.session.commit()
# add grid ids
logger.info(u"adding GRID IDs, if needed")
logger.info(u" looking up GRID IDs")
grid_ids = [
x.grid_id for x in RorGridCrosswalk.query.filter(
RorGridCrosswalk.ror_id == ror_id).all()
]
if not grid_ids:
raise ValueError(
u"at least one ror id corresponding to a grid id is required)")
for g_id in grid_ids:
if not db.session.query(GridId).filter(
GridId.institution_id == institution_id, GridId.grid_id
== g_id).all():
db.session.add(GridId(institution_id=institution_id, grid_id=g_id))
logger.info(u" adding GRID ID {} for {}".format(
g_id, institution_id))
else:
logger.info(u" GRID ID already there")
db.session.commit()
# jump_citing
logger.info(u" populating jump_citing for GRID ID {}".format(g_id))
num_citing_rows = get_sql_answer(
db, "select count(*) from jump_citing where grid_id = '{}'".format(
g_id))
num_citing_rows_view = get_sql_answer(
db, "select count(*) from jump_citing_view where grid_id = '{}'".
format(g_id))
logger.info("num_citing_rows: {}, num_citing_rows_view {}".format(
num_citing_rows, num_citing_rows_view))
if num_citing_rows:
logger.info(
u" {} jump_citing rows already exist for grid id '{}'".
format(num_citing_rows, g_id))
else:
with get_db_cursor() as cursor:
cursor.execute(
"delete from jump_citing where grid_id = '{}'".format(
g_id))
cursor.execute(
"insert into jump_citing (select * from jump_citing_view where grid_id = '{}')"
.format(g_id))
logger.info(
u" created jump_citing rows for grid id {}".format(g_id))
# jump_authorship
logger.info(
u" populating jump_authorship for GRID ID {}".format(g_id))
num_authorship_rows = get_sql_answer(
db,
"select count(*) from jump_authorship where grid_id = '{}'".format(
g_id))
num_authorship_rows_view = get_sql_answer(
db,
"select count(*) from jump_authorship_view where grid_id = '{}'".
format(g_id))
logger.info(
"num_authorship_rows: {}, num_authorship_rows_view {}".format(
num_authorship_rows, num_authorship_rows_view))
if num_authorship_rows:
logger.info(
u" {} jump_authorship rows already exist for grid id {}".
format(num_authorship_rows, g_id))
else:
with get_db_cursor() as cursor:
cursor.execute(
"delete from jump_authorship where grid_id = '{}'".format(
g_id))
cursor.execute(
"insert into jump_authorship (select * from jump_authorship_view where grid_id = '{}')"
.format(g_id))
logger.info(
u" created jump_authorship rows for grid id {}".format(
g_id))
my_packages = Package.query.filter(
Package.institution_id == institution_id)
for my_package in my_packages:
rows_inserted = my_package.update_apc_authorships()
logger.info(
u" inserted apc rows for package {}".format(my_package))
