def main():
# Parse arguments from the command line
parsed_args = parser_args()
# Check interpretation request ID matches expected pattern, and split into ID and version
ir_id, ir_version = get_request_details(parsed_args.interpretation_request)
# Get v6 of interpretation request JSON
ir_json_v6 = get_interpretation_request_json(
ir_id, ir_version, reports_v6=True, testing_on=parsed_args.testing)
# Check that there is only one exisitng clinical report
if num_existing_reports(ir_json_v6) != 1:
sys.exit(
"Expected 1 clinical report but found {num} for interpretation request {ir_id}-{ir_version}"
.format(num=num_existing_reports(ir_json_v6),
ir_id=ir_id,
ir_version=ir_version))
# Create exit questionnaire
eq = create_eq(eventDate=parsed_args.date,
reporter=parsed_args.reporter,
familyLevelQuestions=create_flq(
caseSolvedFamily="no",
segregationQuestion="no",
additionalComments="No tier 1 or 2 variants detected"))
# Push exit questionnaire to CIP-API
put_eq(exit_questionnaire=eq,
ir_id=ir_id,
ir_version=ir_version,
testing_on=parsed_args.testing)
def main():
# Parse arguments from the command line
parsed_args = parser_args()
# Check interpretation request ID matches expected pattern, and split into ID and version
ir_id, ir_version = get_request_details(parsed_args.interpretation_request)
# Get v6 of interpretation request JSON
ir_json_v6 = get_interpretation_request_json(
ir_id, ir_version, reports_v6=True, testing_on=parsed_args.testing)
# Check that there is not already an exisitng clinical report
if num_existing_reports(ir_json_v6):
sys.exit(
"Existing clinical reports detected for interpretation request {ir_id}-{ir_version}"
.format(ir_id=ir_id, ir_version=ir_version))
# Create clinical report object
cr = create_cr(interpretationRequestId=ir_id,
interpretationRequestVersion=int(ir_version),
reportingDate=parsed_args.date,
user=parsed_args.reporter,
referenceDatabasesVersions=get_ref_db_versions(ir_json_v6),
softwareVersions=gel_software_versions(ir_json_v6),
genomicInterpretation="No tier 1 or 2 variants detected")
# Push clinical report to CIP-API
post_cr(clinical_report=cr,
ir_json_v6=ir_json_v6,
testing_on=parsed_args.testing)
def handle_interpretation_request(interpretation_request, force_update=False):
"""Handle an interpretation request for getting tiered variants.
Check if the interpretation request has interpretation_request_data and get
if from the CIPAPI if not. Make a simple_pedigree record and then pass the
interpretation_request to output_variant_tsv for export.
Args:
interpretation_request: JSON representation of an
interpretation_request (output of get_interpretation_request_json).
force_update: Boolean switch to enforce output file overwriting.
"""
# get_or_create interpretation_request_data
ir_id, ir_version = (
interpretation_request['interpretation_request_id'].split('-'))
try:
interpretation_request_data = (
interpretation_request['interpretation_request_data'])
except KeyError:
interpretation_request_data = (get_interpretation_request_json(
ir_id, ir_version))
interpretation_request['interpretation_request_data'] = (
interpretation_request_data)
# make simple pedigree
interpretation_request['simple_pedigree'] = (
get_pedigree_dict(interpretation_request))
output_variant_tsv(interpretation_request, force_update)
def count_tiered_variants(case):
"""Count the number of variants in each tier for a case."""
case['T1'] = 0
case['T2'] = 0
case['T3'] = 0
ir_id, ir_version = case['interpretation_request_id'].split('-')
interpretation_request = get_interpretation_request_json(ir_id, ir_version)
case['interpretation-request_data'] = interpretation_request
for variant in (interpretation_request['interpretation_request_data']
['json_request']['TieredVariants']):
tier = get_variant_tier(variant)
case['T{}'.format(tier)] += 1
def main():
parsed_args = parser_args()
# Parse arguments from the command line
reporter = parsed_args.reporter[
0] # CIP-API user name when generating the clinical report.
selected_date = parsed_args.date[
0] # In "YYYY-MM-DD" format. If date not specified will default to current_date.
check_date(selected_date) # Sanity check on entered date
selected_date = selected_date.strftime(
"%Y-%m-%d") # Convert datetime to string for downstream functions
interpretation_request = parsed_args.interpretation_request[0]
request_id, request_version = get_request_details(
interpretation_request) # Split into request_id & request_version
# Set the CIP-API URL:
if parsed_args.testing == False:
cip_api_url = "https://cipapi.genomicsengland.nhs.uk/api/2/"
else:
cip_api_url = "https://cipapi-beta.genomicsengland.co.uk/api/2/"
print("TESTING MODE active using the beta data at: {}".format(
cip_api_url))
# Get interpretation request data from Interpretation Portal
ir_json = get_interpretation_request_json(request_id,
request_version,
reports_v6=True,
testing_on=parsed_args.testing)
# Check whether summary of findings already exists before preceding:
if len(ir_json.get("clinical_report")) > 0:
sys.exit(
"Processing interpretation request {} cancelled as clinical report already exists, please investigate and process manually"
.format(interpretation_request))
# Parse interpretation request data for required fields
try:
genome_build = ir_json.get(
'assembly'
) # Parse genome assembly from ir_json - genomeAssemblyVersion
full_ir_id = ir_json.get('case_id')
# extract the pipeline software versions from genomics_england_tiering interpreted genome for adding to the summary of findings:
interpreted_genomes = ir_json['interpreted_genome']
for ig in interpreted_genomes:
ig_obj = InterpretedGenome.fromJsonDict(
ig['interpreted_genome_data'])
cip = ig_obj.interpretationService.lower()
if cip == 'genomics_england_tiering':
software_versions = ig_obj.softwareVersions
except KeyError as e:
sys.exit(f'I got a KeyError when parsing ir_json, {str(e)}')
except Exception as e:
sys.exit(
f'Exception thrown generating ir_json to parse for genome assembly, {str(e)}'
)
# Create Exit Questionnaire payload
flqs = create_flq()
validate_object(flqs, "Family Level Questions")
eq = create_eq(selected_date, reporter, flqs)
validate_object(eq, "Exit Questionnaire")
# print(json.dumps(eq.toJsonDict())) # For debugging
# Create Summary of Findings
cr = create_cr(reporter, selected_date, request_id, request_version,
genome_build, software_versions)
validate_object(cr, "Summary of Findings")
# print(json.dumps(cr.toJsonDict())) # For debugging
# Submit the Exit Questionnaire and summary of findings payload via the CIP API:
put_case(request_id,
full_ir_id,
request_version,
cip_api_url,
eq,
cr,
testing_on=parsed_args.testing)