class InvestigatorListAPI(CRUDView):
"""
Investigator API
"""
endpoint = 'investigators_list'
rule = '/investigators'
schemas = {'Investigator': InvestigatorSchema}
@paginated
@use_args(filter_schema_factory(InvestigatorSchema), locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get a paginated investigators
---
template:
path:
get_list.yml
properties:
resource:
Investigator
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = (Investigator.query.filter_by(**filter_params))
# Filter by study
from dataservice.api.study.models import Study
if study_id:
q = (q.join(Investigator.studies).filter(Study.kf_id == study_id))
return (InvestigatorSchema(many=True).jsonify(
Pagination(q, after, limit)))
def post(self):
"""
Create a new investigator
---
template:
path:
new_resource.yml
properties:
resource:
Investigator
"""
body = request.get_json(force=True)
try:
inv = InvestigatorSchema(strict=True).load(body).data
except ValidationError as err:
abort(400,
'could not create investigator: {}'.format(err.messages))
db.session.add(inv)
db.session.commit()
return InvestigatorSchema(201, 'investigator {} created'.format(
inv.kf_id)).jsonify(inv), 201
class FamilyListAPI(CRUDView):
"""
Family API
"""
endpoint = 'families_list'
rule = '/families'
schemas = {'Family': FamilySchema}
@paginated
@use_args(filter_schema_factory(FamilySchema), locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get a paginated familys
---
template:
path:
get_list.yml
properties:
resource:
Family
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = (Family.query.filter_by(**filter_params))
# Filter by study
from dataservice.api.participant.models import Participant
if study_id:
q = (q.join(Family.participants).filter(
Participant.study_id == study_id).group_by(Family.kf_id))
return (FamilySchema(many=True).jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new family
---
template:
path:
new_resource.yml
properties:
resource:
Family
"""
body = request.get_json(force=True)
try:
fam = FamilySchema(strict=True).load(body).data
except ValidationError as err:
abort(400, 'could not create family: {}'.format(err.messages))
db.session.add(fam)
db.session.commit()
return FamilySchema(201, 'family {} created'.format(
fam.kf_id)).jsonify(fam), 201
class StudyListAPI(CRUDView):
"""
Study API
"""
endpoint = 'studies_list'
rule = '/studies'
schemas = {'Study': StudySchema}
@paginated
@use_args(filter_schema_factory(StudySchema),
locations=('query',))
def get(self, filter_params, after, limit):
"""
Get a paginated studies
---
template:
path:
get_list.yml
properties:
resource:
Study
"""
filter_params.pop('study_id', None)
q = (Study.query
.filter_by(**filter_params))
return (StudySchema(many=True)
.jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new study
---
template:
path:
new_resource.yml
properties:
resource:
Study
"""
body = request.get_json(force=True)
try:
st = StudySchema(strict=True).load(body).data
except ValidationError as err:
abort(400, 'could not create study: {}'.format(err.messages))
db.session.add(st)
db.session.commit()
return StudySchema(
201, 'study {} created'.format(st.kf_id)
).jsonify(st), 201
class ParticipantListAPI(CRUDView):
"""
Participant API
"""
endpoint = 'participants_list'
rule = '/participants'
schemas = {'Participant': ParticipantSchema}
@paginated
@use_args(filter_schema_factory(ParticipantSchema), locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get a paginated participants
---
template:
path:
get_list.yml
properties:
resource:
Participant
"""
# Apply entity filter params
q = (Participant.query.filter_by(**filter_params))
return (ParticipantSchema(many=True).jsonify(
Pagination(q, after, limit)))
def post(self):
"""
Create a new participant
---
template:
path:
new_resource.yml
properties:
resource:
Participant
"""
body = request.get_json(force=True)
try:
p = ParticipantSchema(strict=True).load(body).data
except ValidationError as err:
abort(400, 'could not create participant: {}'.format(err.messages))
db.session.add(p)
db.session.commit()
return ParticipantSchema(201, 'participant {} created'.format(
p.kf_id)).jsonify(p), 201
class GenomicFileListAPI(CRUDView):
"""
GenomicFile API
"""
endpoint = 'genomic_files_list'
rule = '/genomic-files'
schemas = {'GenomicFile': GenomicFileSchema}
@paginated
@use_args(filter_schema_factory(GenomicFileFilterSchema),
locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get paginated genomic_files
Retrieves the genomic files stored in the datamodel, then fetch
additional properties that are stored in indexd under the same uuid.
---
template:
path:
get_list.yml
properties:
resource:
GenomicFile
"""
# Remove non-genomic_file attributes from genomic_file filter params
study_id = filter_params.pop('study_id', None)
sequencing_experiment_id = filter_params.pop(
'sequencing_experiment_id', None)
read_group_id = filter_params.pop('read_group_id', None)
biospecimen_id = filter_params.pop('biospecimen_id', None)
# Apply model filter params
q = (GenomicFile.query.filter_by(**filter_params))
# Filter by study
from dataservice.api.participant.models import Participant
from dataservice.api.biospecimen.models import Biospecimen
from dataservice.api.biospecimen_genomic_file.models import (
BiospecimenGenomicFile)
if study_id:
q = (q.join(GenomicFile.biospecimen_genomic_files).join(
BiospecimenGenomicFile.biospecimen).join(
Biospecimen.participant).filter(
Participant.study_id == study_id).group_by(
GenomicFile.kf_id))
from dataservice.api.read_group.models import ReadGroupGenomicFile
from dataservice.api.sequencing_experiment.models import (
SequencingExperimentGenomicFile)
if sequencing_experiment_id:
q = (q.join(SequencingExperimentGenomicFile).filter(
SequencingExperimentGenomicFile.sequencing_experiment_id ==
sequencing_experiment_id))
if read_group_id:
q = (q.join(ReadGroupGenomicFile).filter(
ReadGroupGenomicFile.read_group_id == read_group_id))
if biospecimen_id and not study_id:
q = (q.join(BiospecimenGenomicFile).filter(
BiospecimenGenomicFile.biospecimen_id == biospecimen_id))
# This check is to remove duplicate join on biospecimen genomic file
if biospecimen_id and study_id:
q = (q.filter(
BiospecimenGenomicFile.biospecimen_id == biospecimen_id))
pager = indexd_pagination(q, after, limit)
return (GenomicFileSchema(many=True).jsonify(pager))
def post(self):
"""
Create a new genomic_file
---
template:
path:
new_resource.yml
properties:
resource:
GenomicFile
"""
body = request.get_json(force=True)
try:
gf = GenomicFileSchema(strict=True).load(body).data
except ValidationError as err:
abort(400,
'could not create genomic_file: {}'.format(err.messages))
db.session.add(gf)
db.session.commit()
return GenomicFileSchema(201, 'genomic_file {} created'.format(
gf.kf_id)).jsonify(gf), 201
class BiospecimenGenomicFileListAPI(CRUDView):
"""
BiospecimenGenomicFile List API
"""
endpoint = 'biospecimen_genomic_files_list'
rule = '/biospecimen-genomic-files'
schemas = {'BiospecimenGenomicFile': BiospecimenGenomicFileSchema}
@paginated
@use_args(filter_schema_factory(BiospecimenGenomicFileSchema),
locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get a paginated biospecimen_genomic_files
---
template:
path:
get_list.yml
properties:
resource:
BiospecimenGenomicFile
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = BiospecimenGenomicFile.query.filter_by(**filter_params)
# Filter by study
from dataservice.api.participant.models import Participant
from dataservice.api.biospecimen.models import Biospecimen
if study_id:
q = (q.join(BiospecimenGenomicFile.biospecimen).join(
Biospecimen.participant).filter(
Participant.study_id == study_id))
return (BiospecimenGenomicFileSchema(many=True).jsonify(
Pagination(q, after, limit)))
def post(self):
"""
Create a new biospecimen_genomic_file
---
template:
path:
new_resource.yml
properties:
resource:
BiospecimenGenomicFile
"""
body = request.get_json(force=True)
try:
bs_gf = (BiospecimenGenomicFileSchema(strict=True).load(body).data)
except ValidationError as err:
abort(
400, 'could not create biospecimen_genomic_file: {}'.format(
err.messages))
db.session.add(bs_gf)
db.session.commit()
return BiospecimenGenomicFileSchema(
201, 'biospecimen_genomic_file {} created'.format(
bs_gf.kf_id)).jsonify(bs_gf), 201
class OutcomeListAPI(CRUDView):
"""
Outcome REST API
"""
endpoint = 'outcomes_list'
rule = '/outcomes'
schemas = {'Outcome': OutcomeSchema}
@paginated
@use_args(filter_schema_factory(OutcomeSchema), locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get all outcomes
---
description: Get all outcomes
template:
path:
get_list.yml
properties:
resource:
Outcome
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = Outcome.query.filter_by(**filter_params)
# Filter by study
from dataservice.api.participant.models import Participant
if study_id:
q = (q.join(
Participant.outcomes).filter(Participant.study_id == study_id))
return (OutcomeSchema(many=True).jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new outcome
---
template:
path:
new_resource.yml
properties:
resource:
Outcome
"""
body = request.get_json(force=True)
# Deserialize
try:
o = OutcomeSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400, 'could not create outcome: {}'.format(e.messages))
# Add to and save in database
db.session.add(o)
db.session.commit()
return OutcomeSchema(201, 'outcome {} created'.format(
o.kf_id)).jsonify(o), 201
class SequencingCenterListAPI(CRUDView):
"""
SequencingCenter REST API
"""
endpoint = 'sequencing_centers_list'
rule = '/sequencing-centers'
schemas = {'SequencingCenter': SequencingCenterSchema}
@paginated
@use_args(filter_schema_factory(SequencingCenterSchema),
locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get all sequencing_centers
---
description: Get all sequencing_centers
template:
path:
get_list.yml
properties:
resource:
SequencingCenter
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = (SequencingCenter.query.filter_by(**filter_params))
# Filter by study
from dataservice.api.participant.models import Participant
from dataservice.api.biospecimen.models import Biospecimen
if study_id:
q = (q.join(SequencingCenter.biospecimens).join(
Biospecimen.participant).filter(
Participant.study_id == study_id))
return (SequencingCenterSchema(many=True).jsonify(
Pagination(q, after, limit)))
def post(self):
"""
Create a new sequencing_center
---
template:
path:
new_resource.yml
properties:
resource:
SequencingCenter
"""
body = request.get_json(force=True)
# Deserialize
try:
se = SequencingCenterSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400,
'could not create sequencing_center: {}'.format(e.messages))
# Add to and save in database
db.session.add(se)
db.session.commit()
return SequencingCenterSchema(
201,
'sequencing_center {} created'.format(se.kf_id)).jsonify(se), 201
class TaskListAPI(CRUDView):
"""
Task List API
"""
endpoint = 'tasks_list'
rule = '/tasks'
schemas = {'Task': TaskSchema}
@paginated
@use_args(filter_schema_factory(TaskSchema), locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get a paginated tasks
---
template:
path:
get_list.yml
properties:
resource:
Task
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = (Task.query.filter_by(**filter_params))
# Filter by study
from dataservice.api.participant.models import Participant
from dataservice.api.biospecimen.models import Biospecimen
from dataservice.api.genomic_file.models import GenomicFile
from dataservice.api.task.models import (TaskGenomicFile)
from dataservice.api.biospecimen_genomic_file.models import (
BiospecimenGenomicFile)
if study_id:
q = (q.join(Task.task_genomic_files).join(
TaskGenomicFile.genomic_file).join(
GenomicFile.biospecimen_genomic_files).join(
BiospecimenGenomicFile.biospecimen).join(
Biospecimen.participant).filter(
Participant.study_id == study_id).group_by(
Task.kf_id))
return (TaskSchema(many=True).jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new task
---
template:
path:
new_resource.yml
properties:
resource:
Task
"""
body = request.get_json(force=True)
try:
app = TaskSchema(strict=True).load(body).data
except ValidationError as err:
abort(400, 'could not create task: {}'.format(err.messages))
db.session.add(app)
db.session.commit()
return TaskSchema(201, 'task {} created'.format(
app.kf_id)).jsonify(app), 201
class DiagnosisListAPI(CRUDView):
"""
Diagnosis REST API
"""
endpoint = 'diagnoses_list'
rule = '/diagnoses'
schemas = {'Diagnosis': DiagnosisSchema}
@paginated
@use_args(filter_schema_factory(DiagnosisFilterSchema),
locations=('query',))
def get(self, filter_params, after, limit):
"""
Get all diagnoses
---
description: Get all diagnoses
template:
path:
get_list.yml
properties:
resource:
Diagnosis
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
# Get biospecimen_id and remove from model filter params
biospecimen_id = filter_params.pop('biospecimen_id', None)
# Apply entity filter params
q = Diagnosis.query.filter_by(**filter_params)
# Apply study_id filter and biospecimen_id filter
from dataservice.api.participant.models import Participant
from dataservice.api.biospecimen.models import BiospecimenDiagnosis
if study_id:
q = (q.join(Participant.diagnoses)
.filter(Participant.study_id == study_id))
if biospecimen_id:
q = (q.join(BiospecimenDiagnosis)
.filter(
BiospecimenDiagnosis.biospecimen_id == biospecimen_id))
return (DiagnosisSchema(many=True)
.jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new diagnosis
---
template:
path:
new_resource.yml
properties:
resource:
Diagnosis
"""
body = request.get_json(force=True)
# Deserialize
try:
d = DiagnosisSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400, 'could not create diagnosis: {}'.format(e.messages))
# Add to and save in database
db.session.add(d)
db.session.commit()
return DiagnosisSchema(201, 'diagnosis {} created'
.format(d.kf_id)).jsonify(d), 201
class BiospecimenListAPI(CRUDView):
"""
Biospecimen REST API
"""
endpoint = 'biospecimens_list'
rule = '/biospecimens'
schemas = {'Biospecimen': BiospecimenSchema}
@paginated
@use_args(filter_schema_factory(BiospecimenFilterSchema),
locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get all biospecimens
---
description: Get all biospecimens
template:
path:
get_list.yml
properties:
resource:
Biospecimen
"""
# Get and remove special filter params that are not attributes of model
study_id = filter_params.pop('study_id', None)
diagnosis_id = filter_params.pop('diagnosis_id', None)
genomic_file_id = filter_params.pop('genomic_file_id', None)
# Get and remove any list type filter params that need to be
# handled differently than others
duo_ids = filter_params.pop('duo_ids', None)
# Apply filter params
q = (Biospecimen.query.filter_by(**filter_params))
# Apply duo_ids filter
# Get specimens whose duo ids list includes all values in duo_ids
if duo_ids:
duo_ids = [id_.strip() for id_ in duo_ids[0].split(',')]
q = q.filter(Biospecimen.duo_ids.contains(duo_ids))
# Apply study_id filter and diagnosis_id filter
from dataservice.api.participant.models import Participant
if study_id:
q = (q.join(Participant.biospecimens).filter(
Participant.study_id == study_id))
if diagnosis_id:
q = (q.join(BiospecimenDiagnosis).filter(
BiospecimenDiagnosis.diagnosis_id == diagnosis_id))
if genomic_file_id:
q = (q.join(BiospecimenGenomicFile).filter(
BiospecimenGenomicFile.genomic_file_id == genomic_file_id))
return (BiospecimenSchema(many=True).jsonify(
Pagination(q, after, limit)))
def post(self):
"""
Create a new biospecimen
---
template:
path:
new_resource.yml
properties:
resource:
Biospecimen
"""
body = request.get_json(force=True)
# Deserialize
try:
s = BiospecimenSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400, 'could not create biospecimen: {}'.format(e.messages))
# Add to and save in database
db.session.add(s)
db.session.commit()
return BiospecimenSchema(201, 'biospecimen {} created'.format(
s.kf_id)).jsonify(s), 201
class ReadGroupListAPI(CRUDView):
"""
ReadGroup REST API
"""
endpoint = 'read_groups_list'
rule = '/read-groups'
schemas = {'ReadGroup': ReadGroupSchema}
@paginated
@use_args(filter_schema_factory(ReadGroupFilterSchema),
locations=('query', ))
def get(self, filter_params, after, limit):
"""
Get all read_groups
---
description: Get all read_groups
template:
path:
get_list.yml
properties:
resource:
ReadGroup
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
# Get genomic file id and remove from model filter params
genomic_file_id = filter_params.pop('genomic_file_id', None)
# Apply model filter params
q = ReadGroup.query.filter_by(**filter_params)
# Filter by study
from dataservice.api.participant.models import Participant
from dataservice.api.biospecimen.models import Biospecimen
from dataservice.api.genomic_file.models import GenomicFile
from dataservice.api.biospecimen_genomic_file.models import (
BiospecimenGenomicFile)
if study_id:
q = (q.join(ReadGroup.read_group_genomic_files).join(
ReadGroupGenomicFile.genomic_file).join(
GenomicFile.biospecimen_genomic_files).join(
BiospecimenGenomicFile.biospecimen).join(
Biospecimen.participant).filter(
Participant.study_id == study_id).group_by(
ReadGroup.kf_id))
# Filter by genomic_file_id
if genomic_file_id:
q = (q.join(
ReadGroupGenomicFile,
ReadGroup.kf_id == ReadGroupGenomicFile.read_group_id).filter(
ReadGroupGenomicFile.genomic_file_id == genomic_file_id))
return (ReadGroupSchema(many=True).jsonify(Pagination(q, after,
limit)))
def post(self):
"""
Create a new read_group
---
template:
path:
new_resource.yml
properties:
resource:
ReadGroup
"""
body = request.get_json(force=True)
# Deserialize
try:
rg = ReadGroupSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400, 'could not create read_group: {}'.format(e.messages))
# Add to and save in database
db.session.add(rg)
db.session.commit()
return ReadGroupSchema(201, 'read_group {} created'.format(
rg.kf_id)).jsonify(rg), 201
class FamilyRelationshipListAPI(CRUDView):
"""
FamilyRelationship REST API
"""
endpoint = 'family_relationships_list'
rule = '/family-relationships'
schemas = {'FamilyRelationship': FamilyRelationshipSchema}
@paginated
@use_args(filter_schema_factory(FamilyRelationshipFilterSchema),
locations=('query',))
def get(self, filter_params, after, limit):
"""
Get all family_relationships
---
description: Get all family_relationships
template:
path:
get_list.yml
properties:
resource:
FamilyRelationship
"""
# Get and remove special filter parameters - those which are not
# part of model properties
# Study id
study_id = filter_params.pop('study_id', None)
# Participant id
participant_id = filter_params.pop('participant_id', None)
# Get family relationships joined w participants
q = FamilyRelationship.query_all_relationships(
participant_kf_id=participant_id,
model_filter_params=filter_params)
# Filter by study
if study_id:
from dataservice.api.participant.models import Participant
q = (q.filter(Participant.study_id == study_id))
return (FamilyRelationshipSchema(many=True)
.jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new family_relationship
---
template:
path:
new_resource.yml
properties:
resource:
FamilyRelationship
"""
body = request.get_json(force=True)
# Deserialize
try:
fr = FamilyRelationshipSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400, 'could not create family_relationship: {}'
.format(e.messages))
# Add to and save in database
db.session.add(fr)
db.session.commit()
return FamilyRelationshipSchema(201, 'family_relationship {} created'
.format(fr.kf_id)).jsonify(fr), 201
class BiospecimenListAPI(CRUDView):
"""
Biospecimen REST API
"""
endpoint = 'biospecimens_list'
rule = '/biospecimens'
schemas = {'Biospecimen': BiospecimenSchema}
@paginated
@use_args(filter_schema_factory(BiospecimenFilterSchema),
locations=('query',))
def get(self, filter_params, after, limit):
"""
Get all biospecimens
---
description: Get all biospecimens
template:
path:
get_list.yml
properties:
resource:
Biospecimen
"""
# Get study id, diagnosis_id and remove from model filter params
study_id = filter_params.pop('study_id', None)
diagnosis_id = filter_params.pop('diagnosis_id', None)
# Apply filter params
q = (Biospecimen.query
.filter_by(**filter_params))
# Apply study_id filter and diagnosis_id filter
from dataservice.api.participant.models import Participant
if study_id:
q = (q.join(Participant.biospecimens)
.filter(Participant.study_id == study_id))
if diagnosis_id:
q = (q.join(BiospecimenDiagnosis)
.filter(BiospecimenDiagnosis.diagnosis_id == diagnosis_id))
return (BiospecimenSchema(many=True)
.jsonify(Pagination(q, after, limit)))
def post(self):
"""
Create a new biospecimen
---
template:
path:
new_resource.yml
properties:
resource:
Biospecimen
"""
body = request.get_json(force=True)
# Deserialize
try:
s = BiospecimenSchema(strict=True).load(body).data
# Request body not valid
except ValidationError as e:
abort(400, 'could not create biospecimen: {}'.format(e.messages))
# Add to and save in database
db.session.add(s)
db.session.commit()
return BiospecimenSchema(201, 'biospecimen {} created'
.format(s.kf_id)).jsonify(s), 201
