def get_schema(self):
schema_base = DataSchemas("COPO").get_ui_template().get("copo")
x = data_utils.json_to_object(schema_base.get(self.component, dict()))
return dict(schema_dict=schema_base.get(self.component, dict()).get("fields", list()),
schema=x.fields
)
def get_schema(self):
schema_base = DataSchemas("COPO").get_ui_template().get("copo")
x = data_utils.json_to_object(schema_base.get(self.component, dict()))
return dict(schema_dict=schema_base.get(self.component,
dict()).get("fields", list()),
schema=x.fields)
def generate_ui_schemas(self):
"""
function generates ui schemas
:return:
"""
# instantiate data schema
data_schema = DataSchemas("COPO")
# generate core schemas
temp_dict = DataFormats("COPO").generate_ui_template()
# store schemas in DB
if temp_dict["status"] == "success" and temp_dict["data"]:
data_schema.add_ui_template(temp_dict["data"])
return True
def get_fields_list(field_id):
key_split = field_id.split(".")
new_dict = DataSchemas(field_id.split(".")[0].upper()).get_ui_template()
for kp in key_split[:-1]:
if kp in new_dict:
new_dict = new_dict[kp]
return new_dict["fields"]
def get_type_constraints(self, type_name):
"""
given a type (or a subtype) function returns relevant schemas with associated constraints
:param type_name:
:return:
"""
from dal.copo_base_da import DataSchemas
schema_fields = DataSchemas("COPO").get_ui_template_node('cgCore')
df = self.resolve_field_constraint(schema=schema_fields,
type_name=type_name)
return df
def resolve_ontology_term_data(data, elem):
schema = DataSchemas("COPO").get_ui_template().get("copo").get("ontology_annotation").get("fields")
resolved_data = list()
for f in schema:
if f.get("show_in_table", True):
if f["id"].split(".")[-1] in data:
resolved_data.append(data[f["id"].split(".")[-1]])
if not resolved_data:
resolved_data = str()
elif len(resolved_data) == 1:
resolved_data = resolved_data[0]
return resolved_data
def extract_repo_fields(self, datafile_id=str(), repo=str()):
"""
given a datafile id, and repository type function returns a list of dictionaries of fields matching the repo
:param datafile_id:
:param repo:
:return:
"""
from dal.copo_da import DataFile, CGCore
from dal.copo_base_da import DataSchemas
if not repo: # no repository to filter by
return list()
repo_type_option = lkup.DROP_DOWNS["REPO_TYPE_OPTIONS"]
repo_type_option = [
x for x in repo_type_option if x["value"].lower() == repo.lower()
]
if not repo_type_option:
return list()
repo_type_option = repo_type_option[0]
cg_schema = DataSchemas("COPO").get_ui_template_node('cgCore')
# filter schema items by repo
cg_schema = [
x for x in cg_schema
if x.get("target_repo", str()).strip() != str()
and repo_type_option.get("abbreviation", str()) in
[y.strip() for y in x.get("target_repo").split(',')]
]
record = DataFile().get_record(datafile_id)
description = record.get("description", dict())
attributes = description.get("attributes", dict())
stages = description.get("stages", list())
schema_df = pd.DataFrame(cg_schema)
schema_df.id = schema_df.id.str.lower().str.split(".").str[-1]
schema_df.index = schema_df.id
schema_df = schema_df[['ref', 'id', 'prefix']]
schema_df = schema_df[~schema_df['ref'].isna()]
# get all stage items
all_items = [item for st in stages for item in st.get("items", list())]
# filter stage items - stage items should conform to specifications of the repo
schema_ids = list(schema_df.id)
items = {
item.get("id", str()).lower().split(".")[-1]: st.get("ref",
"").lower()
for st in stages for item in st.get("items", list())
if item.get("id", str()).lower().split(".")[-1] in schema_ids
}
# ...also, account for any filtering performed by client agents (e.g., dependencies in COPO Wizard),
# within the context of the target repo
schema_df = schema_df[schema_df.index.isin(items.keys())]
# obtain attributes for filtered stage items
target_stages = list(set(items.values()))
datafile_attributes = [
v for k, v in attributes.items() if k in target_stages
]
new_dict = dict()
for d in datafile_attributes:
new_dict.update(d)
new_dict_series = pd.Series(new_dict)
new_dict_series.index = new_dict_series.index.str.lower()
schema_df['vals'] = new_dict_series
schema_df['vals'] = schema_df['vals'].fillna('')
schema_df = schema_df[['ref', 'id', 'vals', 'prefix']]
# get composite attributes
composite_attrib = [
x for x in all_items if x["id"] in list(schema_df.id)
and x.get("create_new_item", False)
]
# expand composite attributes
for cattrib in composite_attrib:
comp_series = schema_df.loc[cattrib["id"]]
schema_df = schema_df[~schema_df.id.isin([cattrib["id"]])]
children_schemas = [
x for x in cg_schema if x.get("dependency", str()).lower() ==
comp_series.ref.lower()
]
accessions = comp_series.vals
if isinstance(accessions, str):
accessions = accessions.split(",")
object_ids = [ObjectId(x) for x in accessions if x.strip()]
records = list()
if len(object_ids):
records = cursor_to_list(CGCore().get_collection_handle().find(
{"_id": {
"$in": object_ids
}}))
attr_list = list()
for child in children_schemas:
child_dict = dict(ref=child["ref"],
id=child["id"].split(".")[-1],
prefix=child["prefix"],
vals=[])
attr_list.append(child_dict)
for rec in records:
child_dict["vals"].append(rec.get(child_dict["id"], str()))
if attr_list:
attr_df = pd.DataFrame(attr_list)
attr_df.index = attr_df.id
schema_df = pd.concat([schema_df, attr_df])
schema_df.rename(index=str,
columns={
"ref": "dc",
"id": "copo_id"
},
inplace=True)
dc_list = schema_df.to_dict('records')
return dc_list
def get_copo_schema(component, as_object=False):
"""
function retrieves a required UI schema from the DB.
:param component: a key in the schema_dict to be retrieved
:param as_object: True returns the schema as an object whose element can be accessed using the '.' notation. False
for the traditional python dictionary access
:return:
"""
from dal.copo_base_da import DataSchemas
schema_base = DataSchemas("COPO").get_ui_template().get("copo")
schema_dict = dict(
publication=schema_base.get("publication").get("fields", list()),
person=schema_base.get("person").get("fields", list()),
datafile=schema_base.get("datafile").get("fields", list()),
sample=schema_base.get("sample").get("fields", list()),
source=schema_base.get("source").get("fields", list()),
ontology_annotation=schema_base.get("ontology_annotation").get(
"fields", list()),
comment=schema_base.get("comment").get("fields", list()),
material_attribute_value=schema_base.get(
"material_attribute_value").get("fields", list()),
duration=schema_base.get("duration").get("fields", list()),
miappe_rooting_greenhouse=schema_base.get('miappe').get('rooting').get(
'greenhouse').get("fields", list()),
miappe_rooting_field=schema_base.get('miappe').get('rooting').get(
'field').get("fields", list()),
hydroponics=schema_base.get('miappe').get('nutrients').get(
'hydroponics').get('fields', list()),
soil=schema_base.get('miappe').get('nutrients').get('soil').get(
'fields', list()),
phenotypic_variables=schema_base.get("miappe").get(
"phenotypic_variables").get("fields", list()),
environment_variables=schema_base.get("miappe").get(
"environment_variables").get("fields", list()),
metadata_template=schema_base.get("metadata_template").get(
"fields", list()))
schema = schema_dict.get(component, list())
if schema and as_object:
schema = json_to_object(dict(fields=schema)).fields
return schema
def get_component_schema(self, **kwargs):
return DataSchemas("COPO").get_ui_template_node(self.component)
def get_ena_sequence_stages(self, next_stage_index):
"""
stage callback function: resolves stages based on study type value
:param next_stage_index:
:return:
"""
stage = dict()
description = Description().GET(self.__wzh.description_token)
stages = description["stages"]
attributes = description["attributes"]
if next_stage_index < len(stages):
stage = stages[next_stage_index]
study_type = attributes.get("study_type",
dict()).get("study_type", str())
if not study_type:
# no study type specified, we can't really do anything but signal abort
return dict()
# re-validate dependency if necessary
meta = description.get("meta", dict())
study_type_old = meta.get(stage["ref"] + "_study_type", None)
# remove stages dependent on 'study_type' - remove resolved stages preceding study_type
if not study_type_old == study_type:
cleared_stages = self.__wzh.remove_stage_dependency(
next_stage_index)
# get new dynamic stages based on user current choice
new_stages = list()
# get protocols
protocols = ISAHelpers().get_protocols_parameter_values(study_type)
# get study assay schema
schema_fields = DataSchemas("COPO").get_ui_template_node(
study_type)
# get message dictionary
message_dict = self.__wzh.wiz_message
for pr in protocols:
if len(pr.get("parameterValues", list())) > 0:
title = pr.get("name", str()).title()
ref = pr.get("name", str()).replace(" ", "_")
message = message_dict.get(ref + "_message",
dict()).get("text", str())
stage_dict = dict(title=title,
ref=ref,
message=message,
items=list())
for f in schema_fields:
if f['ref'] in pr.get("parameterValues", list()):
if f.get('show_in_form', False):
f["id"] = f['id'].strip(".").rsplit(".", 1)[1]
f["label"] = htags.trim_parameter_value_label(
f["label"])
# convert select type controls to copo custom select
if f.get("control", str()) == "select":
f["control"] = "copo-single-select"
stage_dict.get("items").append(f)
new_stages.append(stage_dict)
# retain user choice for future reference
meta[stage["ref"] + "_study_type"] = study_type
# save meta
Description().edit_description(self.__wzh.description_token,
dict(meta=meta))
if not new_stages:
# no resolved stages; signal abort
return dict()
# resolve type and data source for generated stages
self.__wzh.sanitise_stages(new_stages)
# register dependency
self.__wzh.set_stage_dependency(new_stages)
# insert new stages to stage list
stage_gap = next_stage_index + 1
stages = cleared_stages[:stage_gap] + new_stages + cleared_stages[
stage_gap:]
# update description record
Description().edit_description(self.__wzh.description_token,
dict(stages=stages))
return False
