class Pipeline(Item):
item_type = 'pipeline'
schema = load_schema('encoded:schemas/pipeline.json')
name_key = 'accession'
embedded = [
'documents', 'documents.award', 'documents.lab',
'documents.submitted_by', 'analysis_steps', 'analysis_steps.documents',
'analysis_steps.pipelines',
'analysis_steps.current_version.software_versions',
'analysis_steps.current_version.software_versions.software',
'analysis_steps.versions', 'analysis_steps.versions.software_versions',
'analysis_steps.versions.software_versions.software', 'lab',
'award.pi.lab', 'standards_page', 'reference_filesets'
]
embedded_with_frame = [
Path(
'analysis_steps.current_version.software_versions.software.references',
exclude=['datasets', 'publication_data']),
Path('analysis_steps.versions.software_versions.software.references',
exclude=['datasets', 'publication_data']),
]
set_status_up = [
'analysis_steps',
'documents',
]
set_status_down = []
audit_inherit = [
'analysis_steps',
]
class PublicationData(FileSet):
item_type = 'publication_data'
schema = load_schema('encoded:schemas/publication_data.json')
embedded = ['submitted_by', 'lab', 'award.pi.lab']
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data']),
]
class HumanDonor(Donor):
item_type = 'human_donor'
schema = load_schema('encoded:schemas/human_donor.json')
embedded = Donor.embedded
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data']),
]
rev = {
'children': ('HumanDonor', 'parents'),
'characterizations': ('DonorCharacterization', 'characterizes')
}
@calculated_property(
schema={
"description":
"Human donor(s) that have this human donor in their parent property.",
"comment":
"Do not submit. Values in the list are reverse links of a human donors that have this biosample under their parents property.",
"title": "Children",
"type": "array",
"items": {
"type": ['string', 'object'],
"linkFrom": "HumanDonor.parents"
},
"notSubmittable": True,
})
def children(self, request, children):
return paths_filtered_by_status(request, children)
class SoftwareVersion(Item):
item_type = 'software_version'
schema = load_schema('encoded:schemas/software_version.json')
embedded = ['software']
embedded_with_frame = [
Path('software.references', exclude=['datasets', 'publication_data']),
]
set_status_up = [
'software',
]
set_status_down = []
def __ac_local_roles__(self):
# Use lab/award from parent software object for access control.
properties = self.upgrade_properties()
root = find_root(self)
software = root.get_by_uuid(properties['software'])
return software.__ac_local_roles__()
class Software(Item):
item_type = 'software'
schema = load_schema('encoded:schemas/software.json')
name_key = 'name'
embedded = [
'versions'
]
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data']),
]
rev = {
'versions': ('SoftwareVersion', 'software')
}
@calculated_property(schema={
"title": "Versions",
"type": "array",
"items": {
"type": "string",
"linkTo": "SoftwareVersion",
},
})
def versions(self, request, versions):
return paths_filtered_by_status(request, versions)
class MouseDonor(Donor):
item_type = 'mouse_donor'
schema = load_schema('encoded:schemas/mouse_donor.json')
embedded = Donor.embedded + [
'genetic_modifications',
'genetic_modifications.modified_site_by_target_id',
'genetic_modifications.modified_site_by_target_id.genes',
'genetic_modifications.treatments'
]
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data']),
]
set_status_up = [
'characterizations',
'source',
'genetic_modifications',
'parent_strains',
'documents',
]
set_status_down = []
def __ac_local_roles__(self):
# Disallow lab submitter edits
return {Authenticated: 'role.viewing_group_member'}
class Series(Dataset, CalculatedSeriesAssay, CalculatedSeriesBiosample,
CalculatedSeriesTarget, CalculatedSeriesTreatment,
CalculatedAssaySynonyms):
item_type = 'series'
base_types = ['Series'] + Dataset.base_types
schema = load_schema('encoded:schemas/series.json')
embedded = Dataset.embedded + [
'biosample_ontology',
'organism',
'target',
'target.genes',
'target.organism',
'related_datasets.biosample_ontology',
'related_datasets.files',
'related_datasets.files.analysis_step_version',
'related_datasets.files.analysis_step_version.analysis_step',
'related_datasets.files.analysis_step_version.analysis_step.pipelines',
'related_datasets.lab',
'related_datasets.submitted_by',
'related_datasets.award.pi.lab',
'related_datasets.replicates.antibody',
'related_datasets.replicates.antibody.targets',
'related_datasets.replicates.library',
'related_datasets.replicates.library.biosample.submitted_by',
'related_datasets.replicates.library.biosample.source',
'related_datasets.replicates.library.biosample.organism',
'related_datasets.replicates.library.biosample.donor.organism',
'related_datasets.replicates.library.biosample.treatments',
'related_datasets.replicates.library.biosample.applied_modifications',
'related_datasets.replicates.library.spikeins_used',
'related_datasets.replicates.library.treatments',
'related_datasets.replicates.libraries',
'related_datasets.replicates.libraries.biosample.submitted_by',
'related_datasets.replicates.libraries.biosample.source',
'related_datasets.replicates.libraries.biosample.organism',
'related_datasets.replicates.libraries.biosample.donor.organism',
'related_datasets.replicates.libraries.biosample.treatments',
'related_datasets.replicates.libraries.biosample.applied_modifications',
'related_datasets.replicates.libraries.spikeins_used',
'related_datasets.replicates.libraries.treatments',
'related_datasets.possible_controls',
'related_datasets.possible_controls.lab',
'related_datasets.target.organism',
'files.platform',
'files.lab',
'files.analysis_step_version.analysis_step',
'files.analysis_step_version.analysis_step.pipelines',
'files.analysis_step_version.analysis_step.versions',
'files.analysis_step_version.analysis_step.versions.software_versions',
'files.analysis_step_version.analysis_step.versions.software_versions.software',
'files.analysis_step_version.software_versions',
'files.analysis_step_version.software_versions.software',
'files.replicate.library.biosample',
'files.library.biosample',
'files.quality_metrics',
'files.quality_metrics.step_run',
'files.quality_metrics.step_run.analysis_step_version.analysis_step',
]
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data']),
Path('related_datasets.references',
exclude=['datasets', 'publication_data']),
]
@calculated_property(
schema={
"title": "Revoked datasets",
"type": "array",
"items": {
"type": "string",
"linkTo": "File",
},
})
def revoked_datasets(self, request, related_datasets):
return [
path for path in related_datasets
if item_is_revoked(request, path)
]
@calculated_property(define=True,
schema={
"title": "Genome assembly",
"type": "array",
"items": {
"type": "string",
},
})
def assembly(self, request, original_files, related_datasets, status):
combined_assembly = set()
for assembly_from_original_files in calculate_assembly(
request, original_files, status):
combined_assembly.add(assembly_from_original_files)
for dataset in related_datasets:
properties = request.embed(dataset, '@@object')
if properties['status'] not in ('deleted', 'replaced'):
for assembly_from_related_dataset in properties['assembly']:
combined_assembly.add(assembly_from_related_dataset)
return list(combined_assembly)
@calculated_property(define=True,
schema={
"title": "Control types",
"type": "array",
"items": {
"type": "string",
},
})
def control_type(self, request, related_datasets):
return request.select_distinct_values('control_type',
*related_datasets)
class Dataset(Item):
base_types = ['Dataset'] + Item.base_types
embedded = [
'files',
'files.replicate',
'files.replicate.experiment',
'files.replicate.experiment.lab',
'files.replicate.experiment.target',
'files.replicate.experiment.target.genes',
'files.submitted_by',
'files.lab',
'revoked_files',
'revoked_files.replicate',
'revoked_files.replicate.experiment',
'revoked_files.replicate.experiment.lab',
'revoked_files.replicate.experiment.target',
'revoked_files.replicate.experiment.target.genes',
'revoked_files.submitted_by',
'submitted_by',
'lab',
'award.pi.lab',
]
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data']),
]
audit_inherit = [
'original_files',
'revoked_files',
'contributing_files'
'submitted_by',
'lab',
'award',
'documents.lab',
]
set_status_up = [
'original_files',
'replicates',
'documents',
'target',
]
set_status_down = []
name_key = 'accession'
rev = {
'original_files': ('File', 'dataset'),
}
@calculated_property(
schema={
"title": "Original files",
"type": "array",
"items": {
"type": ['string', 'object'],
"linkFrom": "File.dataset",
},
"notSubmittable": True,
})
def original_files(self, request, original_files):
return paths_filtered_by_status(request, original_files)
@calculated_property(
schema={
"title": "Contributing files",
"type": "array",
"items": {
"type": "string",
"linkTo": "File",
},
})
def contributing_files(self, request, original_files, status):
derived_from = set()
for path in original_files:
properties = request.embed(path, '@@object?skip_calculated=true')
derived_from.update(
paths_filtered_by_status(request,
properties.get('derived_from', [])))
outside_files = list(derived_from.difference(original_files))
if status in ('released', ):
return paths_filtered_by_status(
request,
outside_files,
include=('released', 'archived', 'in progress'),
)
else:
return paths_filtered_by_status(
request,
outside_files,
exclude=('revoked', 'deleted', 'replaced'),
)
@calculated_property(
schema={
"title": "Files",
"type": "array",
"items": {
"type": "string",
"linkTo": "File",
},
})
def files(self, request, original_files, status):
if status in ('released', 'archived'):
return paths_filtered_by_status(
request,
original_files,
include=('released', 'archived'),
)
else:
return paths_filtered_by_status(
request,
original_files,
exclude=('revoked', 'deleted', 'replaced'),
)
@calculated_property(
schema={
"title": "Revoked files",
"type": "array",
"items": {
"type": "string",
"linkTo": "File",
},
})
def revoked_files(self, request, original_files):
return [
path for path in original_files if item_is_revoked(request, path)
]
@calculated_property(define=True,
schema={
"title": "Genome assembly",
"type": "array",
"items": {
"type": "string",
},
})
def assembly(self, request, original_files, status):
return calculate_assembly(request, original_files, status)
@calculated_property(condition='assembly',
schema={
"title": "Hub",
"type": "string",
})
def hub(self, request):
return request.resource_path(self, '@@hub', 'hub.txt')
class BiosampleType(SharedItem):
item_type = 'biosample_type'
schema = load_schema('encoded:schemas/biosample_type.json')
embedded = []
embedded_with_frame = [
Path('references', exclude=['datasets', 'publication_data'])
]
def unique_keys(self, properties):
keys = super(BiosampleType, self).unique_keys(properties)
keys.setdefault('biosample_type:name', []).append(self.name(properties))
return keys
@calculated_property(schema={
"title": "Name",
"type": "string",
})
def name(self, properties=None):
if properties is None:
properties = self.upgrade_properties()
return u'{}_{}'.format(
properties['classification'], properties['term_id']
).replace(' ', '_').replace(':', '_')
@property
def __name__(self):
return self.name()
@staticmethod
def _get_ontology_slims(registry, term_id, slim_key):
if term_id not in registry['ontology']:
return []
return list(set(
slim for slim in registry['ontology'][term_id][slim_key]
))
@calculated_property(condition='term_id', schema={
"title": "Organ",
"type": "array",
"items": {
"type": "string",
},
})
def organ_slims(self, registry, term_id):
return self._get_ontology_slims(registry, term_id, 'organs')
@calculated_property(condition='term_id', schema={
"title": "Cell",
"type": "array",
"items": {
"type": "string",
},
})
def cell_slims(self, registry, term_id):
return self._get_ontology_slims(registry, term_id, 'cells')
@calculated_property(condition='term_id', schema={
"title": "Developmental slims",
"type": "array",
"items": {
"type": "string",
},
})
def developmental_slims(self, registry, term_id):
return self._get_ontology_slims(registry, term_id, 'developmental')
@calculated_property(condition='term_id', schema={
"title": "System slims",
"type": "array",
"items": {
"type": "string",
},
})
def system_slims(self, registry, term_id):
return self._get_ontology_slims(registry, term_id, 'systems')
@calculated_property(condition='term_id', schema={
"title": "Synonyms",
"type": "array",
"items": {
"type": "string",
},
})
def synonyms(self, registry, term_id):
return self._get_ontology_slims(registry, term_id, 'synonyms')
class Biosample(Item):
item_type = 'biosample'
schema = load_schema('encoded:schemas/biosample.json')
name_key = 'accession'
rev = {
'characterizations': ('BiosampleCharacterization', 'characterizes'),
'parent_of': ('Biosample', 'part_of'),
}
embedded = [
'biosample_ontology',
'donor',
'donor.organism',
'donor.characterizations',
'donor.characterizations.award',
'donor.characterizations.documents',
'donor.characterizations.lab',
'donor.characterizations.submitted_by',
'donor.documents',
'donor.documents.award',
'donor.documents.lab',
'donor.documents.submitted_by',
'submitted_by',
'lab',
'award',
'award.pi.lab',
'source',
'treatments',
'treatments.documents.submitted_by',
'treatments.documents.lab',
'treatments.documents.award',
'documents.lab',
'documents.award',
'documents.submitted_by',
'originated_from',
'originated_from.biosample_ontology',
'part_of',
'part_of.documents',
'part_of.documents.award',
'part_of.documents.lab',
'part_of.documents.submitted_by',
'part_of.characterizations.documents',
'part_of.characterizations.documents.award',
'part_of.characterizations.documents.lab',
'part_of.characterizations.documents.submitted_by',
'part_of.treatments.documents',
'parent_of',
'pooled_from',
'pooled_from.biosample_ontology',
'characterizations.submitted_by',
'characterizations.award',
'characterizations.lab',
'characterizations.documents',
'organism',
'applied_modifications',
'applied_modifications.modified_site_by_target_id',
'applied_modifications.modified_site_by_target_id.genes',
'applied_modifications.treatments'
]
embedded_with_frame = [
Path('donor.references', exclude=['datasets', 'publication_data']),
Path('references', exclude=['datasets', 'publication_data']),
]
audit_inherit = [
'biosample_ontology',
'donor',
'donor.biosample_ontology',
'donor.organism',
'donor.characterizations',
'donor.donor_documents',
'submitted_by',
'lab',
'award',
'source',
'treatments',
'originated_from',
'originated_from.biosample_ontology',
'pooled_from',
'pooled_from.biosample_ontology',
'organism',
'applied_modifications',
'applied_modifications.modified_site_by_target_id'
]
set_status_up = [
'donor',
'part_of',
'pooled_from',
'originated_from',
'genetic_modifications',
'characterizations',
'treatments',
'documents',
'host',
'source',
]
set_status_down = []
@calculated_property(define=True,
schema={"title": "Sex",
"type": "string"})
def sex(self, request, donor=None, model_organism_sex=None, organism=None):
humanFlag = False
if organism is not None:
organismObject = request.embed(organism, '@@object')
if organismObject['scientific_name'] == 'H**o sapiens':
humanFlag = True
if humanFlag is True:
if donor is not None: # try to get the sex from the donor
donorObject = request.embed(donor, '@@object')
if 'sex' in donorObject:
return donorObject['sex']
else:
return 'unknown'
else:
return 'unknown'
else:
if model_organism_sex is not None:
return model_organism_sex
else:
return 'unknown'
@calculated_property(define=True,
schema={"title": "Age",
"type": "string"})
def age(
self,
request,
donor=None,
model_organism_age=None,
organism=None,
sample_collection_age=None,
):
# https://encodedcc.atlassian.net/browse/ENCD-5272
if sample_collection_age is not None:
return sample_collection_age
humanFlag = False
if organism is not None:
organismObject = request.embed(organism, '@@object')
if organismObject['scientific_name'] == 'H**o sapiens':
humanFlag = True
if humanFlag is True:
if donor is not None: # try to get the age from the donor
donorObject = request.embed(donor, '@@object')
if 'age' in donorObject:
return donorObject['age']
else:
return 'unknown'
else:
return 'unknown'
else:
if model_organism_age is not None:
return model_organism_age
else:
return 'unknown'
@calculated_property(define=True,
schema={"title": "Age units",
"type": "string"})
def age_units(
self,
request,
donor=None,
model_organism_age_units=None,
organism=None,
sample_collection_age_units=None,
):
# https://encodedcc.atlassian.net/browse/ENCD-5272
if sample_collection_age_units is not None:
return sample_collection_age_units
humanFlag = False
if organism is not None:
organismObject = request.embed(organism, '@@object')
if organismObject['scientific_name'] == 'H**o sapiens':
humanFlag = True
if humanFlag is True:
if donor is not None: # try to get the age_units from the donor
donorObject = request.embed(donor, '@@object')
if 'age_units' in donorObject:
return donorObject['age_units']
else:
return None
else:
return None
else:
return model_organism_age_units
@calculated_property(define=True,
schema={
"title": "Disease term names",
"description": "Ontology term(s) describing the disease affecting the biosample.",
"comment": "Calculated from disease_term_id",
"type": "array",
"notSubmittable": True,
"uniqueItems": True,
"minItems": 1,
"items": {
"title": "Disease term name",
"description": "Ontology term describing the disease affecting the biosample.",
"type": "string",
},
})
def disease_term_name(self, request, registry, disease_term_id=None):
if disease_term_id is not None:
term_name = list()
for term_id in disease_term_id:
if term_id in registry['ontology']:
term_name.append(registry['ontology'][term_id]['name'])
else:
msg = 'Disease term ID {} is not a valid ID'.format(
term_id
)
raise ValidationFailure('body', ['disease_term_id'], msg)
return term_name
@calculated_property(define=True,
schema={"title": "Health status",
"type": "string"})
def health_status(self, request, donor=None, model_organism_health_status=None, organism=None):
humanFlag = False
if organism is not None:
organismObject = request.embed(organism, '@@object')
if organismObject['scientific_name'] == 'H**o sapiens':
humanFlag = True
if humanFlag is True and donor is not None:
donorObject = request.embed(donor, '@@object')
if 'health_status' in donorObject:
return donorObject['health_status']
else:
return None
else:
if humanFlag is False:
return model_organism_health_status
return None
@calculated_property(define=True,
schema={"title": "Life stage",
"type": "string"})
def life_stage(self, request, donor=None, mouse_life_stage=None, fly_life_stage=None,
worm_life_stage=None, organism=None):
humanFlag = False
if organism is not None:
organismObject = request.embed(organism, '@@object')
if organismObject['scientific_name'] == 'H**o sapiens':
humanFlag = True
if humanFlag is True and donor is not None:
donorObject = request.embed(donor, '@@object')
if 'life_stage' in donorObject:
return donorObject['life_stage']
else:
return 'unknown'
else:
if humanFlag is False:
if mouse_life_stage is not None:
return mouse_life_stage
if fly_life_stage is not None:
return fly_life_stage
if worm_life_stage is not None:
return worm_life_stage
return 'unknown'
@calculated_property(define=True,
schema={"title": "Synchronization",
"type": "string"})
def synchronization(self, request, donor=None, mouse_synchronization_stage=None,
fly_synchronization_stage=None, worm_synchronization_stage=None):
# XXX mouse_synchronization_stage does not exist
if mouse_synchronization_stage is not None:
return mouse_synchronization_stage
if fly_synchronization_stage is not None:
return fly_synchronization_stage
if worm_synchronization_stage is not None:
return worm_synchronization_stage
if donor is not None:
return request.embed(donor, '@@object').get('synchronization')
@calculated_property(schema={
"title": "Model organism genetic modifications",
"description":
"Genetic modifications made in the model organism of the biosample.",
"type": "array",
"items": {
"title": "Model organism genetic modification",
"description": "Genetic modification made in the model organism of the biosample.",
"comment": "See genetic_modification.json for available identifiers.",
"type": "string",
"linkTo": "GeneticModification",
},
}, define=True)
def model_organism_donor_modifications(self, request, donor=None):
if donor is not None:
return request.embed(donor, '@@object').get('genetic_modifications')
@calculated_property(schema={
"title": "Applied modifications",
"description": "All genetic modifications made in either the model organism and/or biosample.",
"type": "array",
"items": {
"title": "Applied modification",
"description": "Genetic modification made in either the model organism and/or biosample.",
"comment": "See genetic_modification.json for available identifiers.",
"type": "string",
"linkTo": "GeneticModification",
}
}, define=True)
def applied_modifications(self, request, genetic_modifications=None, model_organism_donor_modifications=None):
return get_applied_modifications(genetic_modifications, model_organism_donor_modifications)
@calculated_property(schema={
"title": "Characterizations",
"type": "array",
"items": {
"type": ['string', 'object'],
"linkFrom": "BiosampleCharacterization.characterizes",
},
})
def characterizations(self, request, characterizations):
return paths_filtered_by_status(request, characterizations)
@calculated_property(schema={
"description": "The biosample(s) that have this biosample in their part_of property.",
"comment": "Do not submit. Values in the list are reverse links of a biosamples that are part_of this biosample.",
"title": "Child biosamples",
"type": "array",
"items": {
"type": ['string', 'object'],
"linkFrom": "Biosample.part_of",
},
'notSubmittable': True,
})
def parent_of(self, request, parent_of):
return paths_filtered_by_status(request, parent_of)
@calculated_property(schema={
"title": "Age display",
"type": "string",
})
def age_display(
self,
request,
donor=None,
model_organism_age=None,
model_organism_age_units=None,
post_synchronization_time=None,
post_synchronization_time_units=None,
sample_collection_age=None,
sample_collection_age_units=None,
):
# https://encodedcc.atlassian.net/browse/ENCD-5272
if sample_collection_age is not None:
if sample_collection_age == 'unknown':
return ''
if sample_collection_age_units is not None:
return u'{}'.format(
pluralize(
sample_collection_age, sample_collection_age_units
)
)
if post_synchronization_time is not None and post_synchronization_time_units is not None:
return u'{}'.format(
pluralize(post_synchronization_time, post_synchronization_time_units)
)
if donor is not None:
donor = request.embed(donor, '@@object')
if 'age' in donor and 'age_units' in donor:
if donor['age'] == 'unknown':
return ''
return u'{}'.format(pluralize(donor['age'], donor['age_units']))
if model_organism_age is not None and model_organism_age_units is not None:
return u'{}'.format(
pluralize(model_organism_age, model_organism_age_units)
)
return None
@calculated_property(condition='depleted_in_term_name', schema={
"title": "Depleted in term ID",
"type": "string",
})
def depleted_in_term_id(self, request, depleted_in_term_name):
term_lookup = {
'head': 'UBERON:0000033',
'limb': 'UBERON:0002101',
'salivary gland': 'UBERON:0001044',
'male accessory sex gland': 'UBERON:0010147',
'testis': 'UBERON:0000473',
'female gonad': 'UBERON:0000992',
'digestive system': 'UBERON:0001007',
'arthropod fat body': 'UBERON:0003917',
'antenna': 'UBERON:0000972',
'adult maxillary segment': 'FBbt:00003016',
'female reproductive system': 'UBERON:0000474',
'male reproductive system': 'UBERON:0000079'
}
term_id = list()
for term_name in depleted_in_term_name:
if term_name in term_lookup:
term_id.append(term_lookup.get(term_name))
else:
term_id.append('Term ID unknown')
return term_id
@calculated_property(condition='subcellular_fraction_term_name', schema={
"title": "Subcellular fraction term ID",
"type": "string",
})
def subcellular_fraction_term_id(self, request, subcellular_fraction_term_name):
term_lookup = {
'nucleus': 'GO:0005634',
'cytosol': 'GO:0005829',
'chromatin': 'GO:0000785',
'membrane': 'GO:0016020',
'mitochondria': 'GO:0005739',
'nuclear matrix': 'GO:0016363',
'nucleolus': 'GO:0005730',
'nucleoplasm': 'GO:0005654',
'polysome': 'GO:0005844',
'insoluble cytoplasmic fraction': 'NTR:0002594'
}
if subcellular_fraction_term_name in term_lookup:
return term_lookup.get(subcellular_fraction_term_name)
else:
return 'Term ID unknown'
@calculated_property(schema={
"title": "Summary",
"type": "string",
})
def summary(self, request,
organism=None,
donor=None,
age=None,
age_units=None,
life_stage=None,
sex=None,
biosample_ontology=None,
starting_amount=None,
starting_amount_units=None,
depleted_in_term_name=None,
disease_term_name=None,
phase=None,
synchronization=None,
subcellular_fraction_term_name=None,
post_synchronization_time=None,
post_synchronization_time_units=None,
post_treatment_time=None,
post_treatment_time_units=None,
post_nucleic_acid_delivery_time=None,
post_nucleic_acid_delivery_time_units=None,
treatments=None,
part_of=None,
originated_from=None,
transfection_method=None,
transfection_type=None,
preservation_method=None,
genetic_modifications=None,
model_organism_donor_modifications=None):
sentence_parts = [
'organism_name',
'genotype_strain',
'sex_stage_age',
'synchronization',
'term_phrase',
'modifications_list',
'originated_from',
'disease_term_name',
'treatments_phrase',
'post_nucleic_acid_delivery_time',
'preservation_method',
'depleted_in',
'phase',
'fractionated'
]
organismObject = None
donorObject = None
if organism is not None:
organismObject = request.embed(organism, '@@object')
if donor is not None:
donorObject = request.embed(donor, '@@object')
treatment_objects_list = None
if treatments is not None and len(treatments) > 0:
treatment_objects_list = []
for t in treatments:
treatment_objects_list.append(request.embed(t, '@@object'))
part_of_object = None
if part_of is not None:
part_of_object = request.embed(part_of, '@@object')
originated_from_object = None
if originated_from is not None:
originated_from_object = request.embed(originated_from, '@@object')
modifications_list = None
applied_modifications = get_applied_modifications(
genetic_modifications, model_organism_donor_modifications)
if applied_modifications:
modifications_list = []
for gm in applied_modifications:
gm_object = request.embed(gm, '@@object')
modification_dict = {'category': gm_object.get('category')}
if gm_object.get('modified_site_by_target_id'):
modification_dict['target'] = request.embed(
gm_object.get('modified_site_by_target_id'),
'@@object').get('label')
if gm_object.get('introduced_tags'):
modification_dict['tags'] = []
for tag in gm_object.get('introduced_tags'):
tag_dict = {'location': tag['location'], 'name': tag['name']}
if tag.get('promoter_used'):
tag_dict['promoter'] = request.embed(
tag.get('promoter_used'),
'@@object').get('label')
modification_dict['tags'].append(tag_dict)
if 'method' in gm_object:
modifications_list.append((gm_object['method'], modification_dict))
elif 'nucleic_acid_delivery_method' in gm_object:
for item in gm_object['nucleic_acid_delivery_method']:
modifications_list.append((item, modification_dict))
if biosample_ontology:
biosample_type_object = request.embed(biosample_ontology, '@@object')
biosample_term_name = biosample_type_object['term_name']
biosample_type = biosample_type_object['classification']
else:
biosample_term_name = None
biosample_type = None
biosample_dictionary = generate_summary_dictionary(
request,
organismObject,
donorObject,
age,
age_units,
life_stage,
sex,
biosample_term_name,
biosample_type,
starting_amount,
starting_amount_units,
depleted_in_term_name,
disease_term_name,
phase,
subcellular_fraction_term_name,
synchronization,
post_synchronization_time,
post_synchronization_time_units,
post_treatment_time,
post_treatment_time_units,
post_nucleic_acid_delivery_time,
post_nucleic_acid_delivery_time_units,
treatment_objects_list,
preservation_method,
part_of_object,
originated_from_object,
modifications_list)
return construct_biosample_summary([biosample_dictionary],
sentence_parts)
@calculated_property(schema={
"title": "Perturbed",
"description": "A flag to indicate whether the biosample has been perturbed with a treatment or genetic modification.",
"type": "boolean",
"notSubmittable": True,
})
def perturbed(
self,
request,
applied_modifications,
treatments=None,
):
return bool(treatments) or any(
(
request.embed(m, '@@object').get('perturbation', False)
for m in applied_modifications
)
)