def add_or_load_plant_relationship(fpath):
for row in excel_dict_reader(fpath):
plant_name1 = row['Plant1']
plant_name2 = row['Plant2']
plant1 = Plant.objects.get(plant_name=plant_name1)
plant2 = Plant.objects.get(plant_name=plant_name2)
PlantRelationship.objects.get_or_create(subject=plant1, object=plant2)
def add_or_load_accessions(fpath):
for row in excel_dict_reader(fpath):
accession = row['CODE']
collecting_number = row['COLLECTING CODE']
if accession:
Accession.objects.get_or_create(
accession_number=accession,
collecting_number=collecting_number)
def add_or_load_plants(fpath):
for row in excel_dict_reader(fpath):
plant_name = row['PlantName']
seedlot_name = row['SeedLot']
glasshouse = row.get('glasshouse', None)
row_num = row.get('row', None)
pot_number = row.get('pot_number', None)
add_or_create_plant(plant_name, seedlot_name, glasshouse, row_num,
pot_number)
def add_or_load_crosses_data(fpath, only_check=False):
sheet_names = get_sheet_names(fpath)
for sheet_name in sheet_names:
sys.stderr.write(sheet_name + '\n')
sheet_data = list(excel_dict_reader(fpath, sheet_name=sheet_name))
fail = check_data_integrity(sheet_data)
if only_check:
continue
if fail:
sys.exit(1)
# add_plants
for row in sheet_data:
father_seedlot = row[FATHER_SEEDLOT]
father_plant = row[FATHER_PLANT]
add_or_create_plant(father_plant, father_seedlot)
mother_seedlot = row[MOTHER_SEEDLOT]
mother_plant = row[MOTHER_PLANT]
add_or_create_plant(mother_plant, mother_seedlot)
# add crosses
for row in sheet_data:
father_accession = row[FATHER_ACCESSION]
mother_accession = row[MOTHER_ACCESSION]
father_plant = row[FATHER_PLANT]
mother_plant = row[MOTHER_PLANT]
offspring_seedlot = row[OFFSPRING_SEEDLOTN]
offspring_accession = row[OFFSPRING_ACCESSION]
offspring_description = row[OFFSPRING_DESCRIPTION]
offspring_fruit = row.get('Fruit #/Inflorescence', None)
offspring_weight = row.get('PESO', None)
offspring_location = row.get('Location', None)
assay_name = row[ASSAY]
add_or_load_cross(father_accession=father_accession,
mother_accession=mother_accession,
father_plant=father_plant,
mother_plant=mother_plant,
assay_name=assay_name,
offspring_seedlot=offspring_seedlot,
offspring_fruit=offspring_fruit,
offspring_accession=offspring_accession,
offspring_seeds_weight=offspring_weight,
offspring_description=offspring_description,
offspring_location=offspring_location)
def add_or_load_seedlot(fpath):
for row in excel_dict_reader(fpath):
accession = row['Accession']
seed_lot = row['SeedLot']
description = row['Description']
seeds_weight = row['SeedsWeight']
if accession and seed_lot:
accession = Accession.objects.get_or_create(
accession_number=accession)[0]
try:
SeedLot.objects.get_or_create(accession=accession,
name=seed_lot,
description=description,
seeds_weight=seeds_weight)
except IntegrityError:
print(seed_lot)
raise
def add_or_load_excel_traits(fpath, assays):
with transaction.atomic():
for row in excel_dict_reader(fpath):
name = row.pop('name')
type_ = row.pop('type')
#description = row.get('description', None)
try:
type_ = Cvterm.objects.get(name=type_, cv__name=TRAIT_TYPES_CV)
except Cvterm.DoesNotExist:
msg = 'Trait type not loaded yet in db: {}'.format(type_)
raise RuntimeError(msg)
trait, trait_created = Trait.objects.get_or_create(name=name, type=type_)
for assay in assays:
try:
assay = Assay.objects.get(name=assay)
except Assay.DoesNotExist:
raise RuntimeError('Assay not loaded yet in db: {}'.format(assay))
created = AssayTrait.objects.get_or_create(assay=assay,
trait=trait)[1]
if created:
assign_perm('view_trait', assay.owner, trait)
if trait_created:
for prop, prop_value in row.items():
if not prop_value:
continue
try:
prop_type = Cvterm.objects.get(cv__name=TRAIT_PROPS_CV,
name=prop)
except Cvterm.DoesNotExist:
print('#{}#'.format(prop))
raise
try:
TraitProp.objects.create(trait=trait, type=prop_type,
value=prop_value)
except Exception:
print(trait.name, prop_type.name, prop_value)
def add_excel_related_observations(fpath, assay_header=ASSAY_HEADER,
plant_header=PLANT_HEADER,
plant_part_header=PLANT_PART_HEADER,
accession_header=ACCESSION_HEADER,
photo_header=PHOTO_HEADER,
perm_gr=None,
one_part_per_plant=False,
qual_translator=None):
rel_type = Cvterm.objects.get(cv__name='relationship_types',
name='obtained_from')
with transaction.atomic():
for entry in excel_dict_reader(fpath):
plant_name = entry.pop(plant_header)
accession_number = entry.pop(accession_header)
plant_part = entry.pop(plant_part_header)
assay_name = entry.pop(assay_header)
if perm_gr is None:
perm_gr = assay_name
perm_gr = Group.objects.get(name=perm_gr)
try:
photo_id = entry.pop(photo_header)
except KeyError:
photo_id = None
try:
observer = entry.pop('author')
except KeyError:
observer = None
try:
creation_time = entry.pop('date')
except KeyError:
creation_time = None
_delete_unused_fields(entry)
obs_image = None
photo_uuid = None
if photo_id:
try:
obs_image = ObservationImages.objects.get(image__icontains=photo_id)
photo_uuid = obs_image.observation_image_uid
except ObservationImages.DoesNotExist:
print(plant_name, plant_part, accession_number, photo_id)
# create observation_entity
obs_entity = get_or_create_obs_entity(accession_number, assay_name,
plant_part,
plant_name=plant_name,
perm_gr=perm_gr,
photo_uuid=photo_uuid,
one_part_per_plant=one_part_per_plant)
# print(obs_entity)
observation_pairs = _parse_trait_values(entry)
# print(entry)
# print(observation_pairs)
for trait_name, value in observation_pairs.items():
if not value:
continue
if qual_translator and trait_name in qual_translator:
try:
value = qual_translator[trait_name][str(value)]
except KeyError:
raise KeyError('{} not in {} trait'.format(value, trait_name))
observation = add_observation(obs_entity=obs_entity,
trait_name=trait_name,
assay_name=assay_name, value=value,
creation_time=creation_time,
observer=observer)
if obs_image:
ObservationRelationship.objects.create(subject=observation,
object=obs_image.observation,
type=rel_type)
def add_excel_observations(fpath, observer=None, assay=None,
plant_part=None,
accession_header='accession',
value_header='value', date_header='Fecha',
observer_header='Autor',
assay_header='assay',
plant_part_header='plant_part',
obs_uid_header='part_uid',
plant_name_header='plant_name',
plant_number_header='plant_number',
trait_header='trait',
view_perm_group=None,
raise_on_error=True,
qualitative_translator=None):
with transaction.atomic():
for row in excel_dict_reader(fpath):
value = row.get(value_header, None)
if value is None or value == 'nd':
continue
plant_name = row.get(plant_name_header, None)
plant_part = row.get(plant_part_header, plant_part)
obs_entity_name = row.get(obs_uid_header, None)
plant_number = row.get(plant_number_header, None)
accession = row.get(accession_header, None)
assayname = row.get(assay_header, assay)
if view_perm_group is None:
view_perm_group = assayname
perm_gr = Group.objects.get(name=view_perm_group)
try:
obs_entity = get_or_create_obs_entity(accession_number=accession,
assay_name=assayname,
plant_part=plant_part,
plant_name=plant_name,
obs_entity_name=obs_entity_name,
plant_number=plant_number,
perm_gr=perm_gr)
except ValueError as error:
if raise_on_error:
raise
else:
sys.stderr.write(str(error) + '\n')
continue
creation_time = row.get(date_header)
if creation_time is None:
creation_time = datetime.datetime.now()
creation_time = OUR_TIMEZONE.localize(creation_time, is_dst=True)
observer = row.get(observer_header, observer)
trait_name = row.get(trait_header)
if qualitative_translator:
try:
value = qualitative_translator[trait_name][str(value)]
except KeyError as error:
if raise_on_error:
raise
else:
msg = 'Qualitative trait "{}" has no {} value in translator\n'
sys.stderr.write(msg.format(trait_name, value))
continue
try:
obs = add_observation(obs_entity, trait_name, assayname,
value, creation_time, observer)
assign_perm('view_observation', perm_gr, obs)
except ValueError as error:
if raise_on_error:
raise
else:
sys.stderr.write(str(error) + '\n')
continue