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 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 get(self, filter_params, after, limit):
"""
Get all phenotypes
---
description: Get all phenotypes
template:
path:
get_list.yml
properties:
resource:
Phenotype
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = Phenotype.query.filter_by(**filter_params)
# Filter by study
from dataservice.api.participant.models import Participant
if study_id:
q = (q.join(Participant.phenotypes).filter(
Participant.study_id == study_id))
return (PhenotypeSchema(many=True).jsonify(Pagination(q, after,
limit)))
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 get(self, filter_params, after, limit):
"""
Get all sequencing_experiments
---
description: Get all sequencing_experiments
template:
path:
get_list.yml
properties:
resource:
SequencingExperiment
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = (SequencingExperiment.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(SequencingExperiment.genomic_files).join(
GenomicFile.biospecimen_genomic_files).join(
BiospecimenGenomicFile.biospecimen).join(
Biospecimen.participant).filter(
Participant.study_id == study_id).group_by(
SequencingExperiment.kf_id))
return (SequencingExperimentSchema(many=True).jsonify(
Pagination(q, after, limit)))
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 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 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 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 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 get(self, filter_params, after, limit):
"""
Get a paginated cavatica_apps
---
template:
path:
get_list.yml
properties:
resource:
CavaticaApp
"""
# Get study id and remove from model filter params
study_id = filter_params.pop('study_id', None)
q = (CavaticaApp.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.cavatica_task.models import (
CavaticaTask,
CavaticaTaskGenomicFile
)
from dataservice.api.biospecimen_genomic_file.models import (
BiospecimenGenomicFile
)
if study_id:
q = (q.join(CavaticaApp.cavatica_tasks)
.join(CavaticaTask.cavatica_task_genomic_files)
.join(CavaticaTaskGenomicFile.genomic_file)
.join(GenomicFile.biospecimen_genomic_files)
.join(BiospecimenGenomicFile.biospecimen)
.join(Biospecimen.participant)
.filter(Participant.study_id == study_id)
.group_by(CavaticaApp.kf_id))
return (CavaticaAppSchema(many=True)
.jsonify(Pagination(q, after, limit)))
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 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 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)))