def test_migrate_cancer_interpretation_request(self):
"""
Test passing with ILMN-8308-1 cancer IR
"""
# tests with all nullable fields being filled
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.CancerInterpretationRequest,
VERSION_400,
fill_nullables=True).create(
) # we need to enforce that it can be cast to int
self._validate(old_instance)
self._check_non_empty_fields(old_instance)
migrated_instance = MigrateReports400To500(
).migrate_cancer_interpretation_request(old_instance=old_instance,
assembly='GRCh38')
self._validate(migrated_instance)
# test with all nullable fields being null
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.CancerInterpretationRequest,
VERSION_400,
fill_nullables=False).create(
) # we need to enforce that it can be cast to int
old_instance.cancerParticipant.LDPCode = "needs to be filled"
self._validate(old_instance)
migrated_instance = MigrateReports400To500(
).migrate_cancer_interpretation_request(old_instance=old_instance,
assembly='GRCh38')
self._validate(migrated_instance)
def test_register_custom_factory(self):
## registering GA4GH variant factory
GenericFactoryAvro.register_factory(Variant,
GA4GHVariantFactory,
version="4.0.0")
factory = GenericFactoryAvro.get_factory_avro(Variant, "4.0.0")
instances = factory.create_batch(5)
for instance in instances:
self.assertTrue(instance.validate(instance.toJsonDict()))
self.assertTrue(instance.referenceBases in ["A", "C", "G", "T"])
## register CancerReportedVariantsFactory
GenericFactoryAvro.register_factory(
protocols.reports_3_0_0.ReportedVariantCancer,
CancerReportedVariantsFactory,
version="3.0.0")
factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_3_0_0.CancerInterpretationRequest, "3.0.0")
instances = factory.create_batch(5)
for instance in instances:
self.assertTrue(instance.validate(instance.toJsonDict()))
for tiered_variant in instance.TieredVariants:
self.assertTrue(tiered_variant.reportedVariantCancer.reference
in ["A", "C", "G", "T"])
self.assertTrue(tiered_variant.reportedVariantCancer.alternate
in ["A", "C", "G", "T"])
def test_migrate_interpretation_request_rd(self):
# tests with all nullable fields being filled
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretationRequestRD, VERSION_400, fill_nullables=True
).create()
if old_instance.pedigree.members:
for member in old_instance.pedigree.members:
if member.disorderList:
for disorder in member.disorderList:
disorder.ageOfOnset = "1.5"
self._validate(old_instance)
self._check_non_empty_fields(old_instance)
migrated_instance = MigrateReports400To500().migrate_interpretation_request_rd(
old_instance=old_instance, assembly='GRCh38'
)
self._validate(migrated_instance)
for other_file in migrated_instance.otherFiles.values():
self.assertIsInstance(other_file, self.new_model.File)
# test with all nullable fields being null
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretationRequestRD, VERSION_400, fill_nullables=False
).create()
self._validate(old_instance)
migrated_instance = MigrateReports400To500().migrate_interpretation_request_rd(
old_instance=old_instance, assembly='GRCh38'
)
self._validate(migrated_instance)
if migrated_instance.otherFiles is not None:
for other_file in migrated_instance.otherFiles.values():
self.assertIsInstance(other_file, self.new_model.File)
def test_migrate_interpretation_request_rd_600_300(self,
fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
reports_6_0_0.InterpretationRequestRD,
VERSION_70,
fill_nullables=fill_nullables).create()
# there is an explicit check for pedigree even though it's nullable.
old_instance.pedigree = GenericFactoryAvro.get_factory_avro(
reports_6_0_0.Pedigree, VERSION_70,
fill_nullables=fill_nullables).create()
old_instance.additionalInfo = {}
old_instance.additionalInfo['cellbaseVersion'] = '1.0'
old_instance.additionalInfo['tieringVersion'] = '1.0'
old_instance.additionalInfo['analysisReturnUri'] = 'uri.com'
old_ig = GenericFactoryAvro.get_factory_avro(
reports_6_0_0.InterpretedGenome,
VERSION_70,
fill_nullables=fill_nullables).create()
self._validate(old_instance)
if fill_nullables:
self._check_non_empty_fields(old_instance)
self.assertIsInstance(old_instance,
reports_6_0_0.InterpretationRequestRD)
migrated_instance = MigrationHelpers.reverse_migrate_interpretation_request_rd_to_v3(
old_instance.toJsonDict(), old_ig.toJsonDict())
self.assertIsInstance(migrated_instance,
reports_3_0_0.InterpretationRequestRD)
self._validate(migrated_instance)
self.assertEqual(migrated_instance.versionControl.GitVersionControl,
'3.0.0')
def test_migrate_interpreted_genome_rd(self):
""" Test passing on 3000 real cases"""
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretedGenomeRD,
VERSION_300,
fill_nullables=False).create()
self._validate(old_instance)
migrated_instance = MigrateReports3To4().migrate_interpreted_genome_rd(
old_instance=old_instance)
self._validate(migrated_instance)
# fill all nullables
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretedGenomeRD,
VERSION_300,
fill_nullables=True).create()
self._validate(old_instance)
migrated_instance = MigrateReports3To4().migrate_interpreted_genome_rd(
old_instance=old_instance)
self._validate(migrated_instance)
old_hgnc_symbols = [
re.genomicFeature.HGNC for rv in old_instance.reportedVariants
for re in rv.reportEvents
]
new_hgnc_symbols = [
re.genomicFeature.hgnc for rv in migrated_instance.reportedVariants
for re in rv.reportEvents
]
self.assertEqual(old_hgnc_symbols, new_hgnc_symbols)
def test_migrate_rd_interpretation_request(self, fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretationRequestRD, VERSION_61, fill_nullables=fill_nullables
).create(interpretationRequestVersion=1)
old_instance.additionalInfo = {}
old_instance.additionalInfo['cellbaseVersion'] = '1.0'
old_instance.additionalInfo['tieringVersion'] = '1.0'
old_instance.additionalInfo['analysisReturnUri'] = 'uri.com'
self._validate(old_instance)
if fill_nullables:
self._check_non_empty_fields(old_instance)
old_ig = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretedGenomeRD, VERSION_61, fill_nullables=fill_nullables
).create(interpretationRequestVersion=1, interpretationRequestId=old_instance.interpretationRequestId)
self._validate(old_ig)
if fill_nullables:
self._check_non_empty_fields(old_ig)
new_instance = MigrateReports500To400().migrate_interpretation_request_rd(
old_instance=old_instance, old_ig=old_ig)
self.assertTrue(isinstance(new_instance, self.new_model.InterpretationRequestRD))
self._validate(new_instance)
if fill_nullables:
self._check_variant_coordinates(
old_variants=old_ig.variants,
new_variants=new_instance.tieredVariants,
)
def test_migrate_cancer_interpretation_request(self):
"""
Test passing with ILMN-8308-1 cancer IR
"""
# tests with all nullable fields being filled
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.CancerInterpretationRequest, VERSION_400, fill_nullables=True
).create() # we need to enforce that it can be cast to int
valid_cancer_origins = ['germline_variant', 'somatic_variant']
for tiered_variant in old_instance.tieredVariants:
if tiered_variant.alleleOrigins[0] not in valid_cancer_origins:
tiered_variant.alleleOrigins[0] = random.choice(valid_cancer_origins)
self._validate(old_instance)
self._check_non_empty_fields(old_instance)
migrated_instance = MigrateReports400To500().migrate_cancer_interpretation_request(
old_instance=old_instance, assembly='GRCh38'
)
self._validate(migrated_instance)
# test with all nullable fields being null
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.CancerInterpretationRequest, VERSION_400, fill_nullables=False
).create() # we need to enforce that it can be cast to int
for tiered_variant in old_instance.tieredVariants:
if tiered_variant.alleleOrigins[0] not in valid_cancer_origins:
tiered_variant.alleleOrigins[0] = random.choice(valid_cancer_origins)
old_instance.cancerParticipant.LDPCode = "needs to be filled"
self._validate(old_instance)
migrated_instance = MigrateReports400To500().migrate_cancer_interpretation_request(
old_instance=old_instance, assembly='GRCh38'
)
self._validate(migrated_instance)
def test_migrate_cancer_clinical_report(self):
# creates a random clinical report cancer for testing filling null values
cr_c_400 = GenericFactoryAvro.get_factory_avro(
self.old_model.ClinicalReportCancer, VERSION_400, fill_nullables=True
).create(interpretationRequestVersion='1') # we need to enforce that it can be cast to int
valid_cancer_origins = ['germline_variant', 'somatic_variant']
if cr_c_400.candidateVariants:
for candidate_variant in cr_c_400.candidateVariants:
if candidate_variant.alleleOrigins[0] not in valid_cancer_origins:
candidate_variant.alleleOrigins[0] = random.choice(valid_cancer_origins)
self._validate(cr_c_400)
self._check_non_empty_fields(cr_c_400)
assembly = 'grch38'
participant_id = "no_one"
sample_ids = {
'germline_variant': 'germline1',
'somatic_variant': 'somatic1'
}
migrated_cir_500 = MigrateReports400To500().migrate_cancer_clinical_report(
cr_c_400, assembly=assembly, participant_id=participant_id, sample_ids=sample_ids
)
self._validate(migrated_cir_500)
self._check_non_empty_fields(migrated_cir_500,
exclusions=["genomicChanges", "references", "actionType", "otherIds",
"groupOfVariants", "score", "vendorSpecificScores",
"variantClassification", "fdp50", "recurrentlyReported", "others",
"phaseSet"])
self._check_variant_coordinates(
[variant.reportedVariantCancer for variant in cr_c_400.candidateVariants],
migrated_cir_500.variants,
reports_5_0_0.Assembly.GRCh38
)
# creates a random clinical report cancer for testing not filling null values
cr_c_400 = GenericFactoryAvro.get_factory_avro(
self.old_model.ClinicalReportCancer, VERSION_400, fill_nullables=False
).create(interpretationRequestVersion='1')
if cr_c_400.candidateVariants:
for candidate_variant in cr_c_400.candidateVariants:
if candidate_variant.alleleOrigins[0] not in valid_cancer_origins:
candidate_variant.alleleOrigins[0] = random.choice(valid_cancer_origins)
self._validate(cr_c_400)
assembly = 'hg19'
participant_id = "no_one"
sample_ids = {
'germline_variant': 'germline1',
'somatic_variant': 'somatic1'
}
migrated_cir_500 = MigrateReports400To500().migrate_cancer_clinical_report(
cr_c_400, assembly=assembly, participant_id=participant_id, sample_ids=sample_ids
)
self._validate(migrated_cir_500)
self.assertTrue(cr_c_400.candidateVariants is None)
self.assertTrue(migrated_cir_500.variants is None)
def test_register_custom_factory(self):
# creates a custom factory and registers it
class ReportVersionControlFactory(FactoryAvro):
def __init__(self, *args, **kwargs):
super(ReportVersionControlFactory, self).__init__(*args, **kwargs)
class Meta:
model = protocols.reports_4_2_0.ReportVersionControl
_version = VERSION_500
gitVersionControl = "4.3.0-SNAPSHOT"
GenericFactoryAvro.register_factory(
protocols.reports_4_2_0.ReportVersionControl,
ReportVersionControlFactory,
version=VERSION_500
)
interpretation_request_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.InterpretationRequestRD,
version=VERSION_500
)
instance_ir = interpretation_request_factory()
self.assertTrue(instance_ir.validate(instance_ir.toJsonDict()))
self.assertTrue(instance_ir.versionControl.gitVersionControl == "4.3.0-SNAPSHOT")
# now creates another factory generating values for nullable fields
file_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.File,
VERSION_500,
False,
False
)
GenericFactoryAvro.register_factory(
protocols.reports_4_2_0.File,
file_factory,
VERSION_500,
True
)
interpretation_request_factory2 = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.InterpretationRequestRD,
version=VERSION_500,
fill_nullables=True
)
instance_ir2 = interpretation_request_factory2()
self.assertTrue(instance_ir2.validate(instance_ir2.toJsonDict()))
self.assertFalse(instance_ir2.versionControl.gitVersionControl == "4.3.0-SNAPSHOT")
# now registers the factory for ReportVersionControl when filling nullables
GenericFactoryAvro.register_factory(
protocols.reports_4_2_0.ReportVersionControl,
ReportVersionControlFactory,
version=VERSION_500,
fill_nullables=True
)
instance_ir3 = interpretation_request_factory2()
self.assertTrue(instance_ir3.validate(instance_ir3.toJsonDict()))
self.assertTrue(instance_ir3.versionControl.gitVersionControl == "4.3.0-SNAPSHOT")
def test_migrate_interpretation_request_rd_to_interpreted_genome_rd(self):
# creates a random clinical report cancer for testing filling null values
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretationRequestRD, VERSION_400, fill_nullables=True
).create() # we need to enforce that it can be cast to int
self._validate(old_instance)
self._check_non_empty_fields(old_instance)
assembly = 'grch38'
interpretation_service = "testing"
new_instance = MigrateReports400To500().migrate_interpretation_request_rd_to_interpreted_genome_rd(
old_instance, assembly=assembly, interpretation_service=interpretation_service,
reference_database_versions={'dbSnp': 'rs12345'},
software_versions={'intogen': '1.5'},
report_url="blablabla.blah",
comments=["bla", "bla!", "bla?"]
)
self._validate(new_instance)
self._check_non_empty_fields(new_instance,
exclusions=["alleleFrequencies", "genomicChanges", "proteinChanges",
"cdnaChanges", "dbSnpId", "cosmicIds", "clinVarIds",
"variantConsequences", "drugResponseClassification",
"functionalEffect", "traitAssociation", "tumorigenesisClassification",
"clinicalSignificance", "variantAttributes", "vaf"])
self._check_variant_coordinates(
old_instance.tieredVariants,
new_instance.variants,
reports_5_0_0.Assembly.GRCh38
)
self.assertEqual(old_instance.tieringVersion, new_instance.softwareVersions['tiering'])
# creates a random clinical report cancer for testing not filling null values
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretationRequestRD, VERSION_400, fill_nullables=False
).create()
self._validate(old_instance)
assembly = 'hg19'
new_instance = MigrateReports400To500().migrate_interpretation_request_rd_to_interpreted_genome_rd(
old_instance, assembly=assembly, interpretation_service=interpretation_service,
reference_database_versions={'dbSnp': 'rs12345'},
software_versions={'intogen': '1.5'},
report_url="blablabla.blah",
comments=["bla", "bla!", "bla?"]
)
self._validate(new_instance)
self._check_variant_coordinates(
old_instance.tieredVariants,
new_instance.variants,
reports_5_0_0.Assembly.GRCh37
)
def test_batch(self):
# builds a batch of 5 interpretation requests
interpretation_request_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.InterpretationRequestRD,
version=VERSION_500
)
instances = interpretation_request_factory.create_batch(5)
for instance in instances:
self.assertTrue(instance.validate(instance.toJsonDict()))
self.assertTrue(instances[0].interpretationRequestId != instances[1].interpretationRequestId)
GenericFactoryAvro.register_factory(protocols.ga4gh_3_0_0.Variant, GA4GHVariantFactory)
GenericFactoryAvro.get_factory_avro(protocols.ga4gh_3_0_0.Variant)
def test_build_version_with_hotfix(self):
# get an interpretation request RD for reports 5.0.0
interpretation_request_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_5_0_0.InterpretationRequestRD,
version=VERSION_61)
instance = interpretation_request_factory()
self.assertTrue(instance.validate(instance.toJsonDict()))
# now try the same with the build version including the hotfix version
interpretation_request_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_5_0_0.InterpretationRequestRD, version="6.1.0")
instance = interpretation_request_factory()
self.assertTrue(instance.validate(instance.toJsonDict()))
def test_nullable_fields(self):
# creates a factory for File not filling nullable fields and registers it in cache
# as a factory that fill nullable fields
# NOTE: this is the workaround to circumvent the loop in model definition
file_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.File, VERSION_500, False, False)
GenericFactoryAvro.register_factory(protocols.reports_4_2_0.File,
file_factory, VERSION_500, True)
# get an interpretation request RD for reports 4.2.0
interpretation_request_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.InterpretationRequestRD,
version=VERSION_500,
fill_nullables=True)
instance = interpretation_request_factory()
self.assertTrue(instance.validate(instance.toJsonDict()))
def test_equality(self):
"""
Ensures that validation fails when other object than a dict is passed
:return:
"""
first_instance = GenericFactoryAvro.get_factory_avro(
InterpretationRequestRD, VERSION_400,
fill_nullables=False).create()
second_instance = GenericFactoryAvro.get_factory_avro(
InterpretationRequestRD, VERSION_400,
fill_nullables=False).create()
self.assertFalse(first_instance.equals(second_instance) is True)
self.assertFalse(second_instance.equals(first_instance) is True)
self.assertTrue(first_instance.equals(first_instance) is True)
self.assertTrue(second_instance.equals(second_instance) is True)
def test_migrate_interpreted_genome_rd_300_600(self, fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
reports_3_0_0.InterpretedGenomeRD, VERSION_300, fill_nullables=fill_nullables
).create()
self._validate(old_instance)
if fill_nullables:
for rsv in old_instance.reportedStructuralVariants:
for cg in rsv.calledGenotypes:
cg.copyNumber = int(round(uniform(-100, 100)))
cg.phaseSet = int(round(uniform(-100, 100)))
cg.depthReference = int(round(uniform(-100, 100)))
cg.depthAlternate = int(round(uniform(-100, 100)))
for rv in old_instance.reportedVariants:
for cg in rv.calledGenotypes:
cg.copyNumber = int(round(uniform(-100, 100)))
cg.phaseSet = int(round(uniform(-100, 100)))
cg.depthReference = int(round(uniform(-100, 100)))
cg.depthAlternate = int(round(uniform(-100, 100)))
self._check_non_empty_fields(old_instance)
migrated_instance = MigrationHelpers.migrate_interpreted_genome_rd_to_latest(
old_instance.toJsonDict(), assembly='GRCh38', interpretation_request_version=1
)
self.assertIsInstance(migrated_instance, reports_6_0_0.InterpretedGenome)
self._validate(migrated_instance)
def test_migrate_cancer_interpreted_genome(self, fill_nullables=True):
old_c_ig = GenericFactoryAvro.get_factory_avro(
self.old_model.CancerInterpretedGenome, VERSION_61, fill_nullables=fill_nullables
).create()
new_c_ig = MigrateReports500To600().migrate_cancer_interpreted_genome(
old_instance=old_c_ig,
)
self.assertIsInstance(new_c_ig, self.new_model.InterpretedGenome)
self._validate(new_c_ig)
self.assertEqual(new_c_ig.versionControl.gitVersionControl, '6.0.0')
attributes = [
"interpretationRequestId", "interpretationRequestVersion", "interpretationService", "reportUrl",
"referenceDatabasesVersions", "softwareVersions", "comments",
]
for attribute in attributes:
if getattr(old_c_ig, attribute) is not None:
self.assertEqual(getattr(new_c_ig, attribute), getattr(old_c_ig, attribute))
self.assertEqual(new_c_ig.versionControl.gitVersionControl, "6.0.0")
old_variants = old_c_ig.variants
new_variants = new_c_ig.variants
for old, new in zip(old_variants, new_variants):
self.assertIsInstance(new, self.new_model.SmallVariant)
self.assertEqual(
new,
MigrateReports500To600().migrate_variant_cancer(variant=old)
)
def test_migrate_interpreted_genome_rd(self, fill_nullables=True):
old_ig_rd = GenericFactoryAvro.get_factory_avro(
self.old_model.InterpretedGenomeRD, VERSION_61, fill_nullables=fill_nullables
).create()
new_ig_rd = MigrateReports500To600().migrate_interpreted_genome_rd(old_instance=old_ig_rd)
self._validate(new_ig_rd)
self.assertIsInstance(new_ig_rd, self.new_model.InterpretedGenome)
self.assertIsInstance(new_ig_rd.versionControl, self.new_model.ReportVersionControl)
self.assertEqual(new_ig_rd.versionControl.gitVersionControl, '6.0.0')
attributes = [
"interpretationRequestId", "interpretationRequestVersion", "interpretationService", "reportUrl",
"referenceDatabasesVersions", "softwareVersions", "comments",
]
for attribute in attributes:
if getattr(old_ig_rd, attribute) is not None:
self.assertEqual(getattr(new_ig_rd, attribute), getattr(old_ig_rd, attribute))
old_variants = old_ig_rd.variants
new_variants = new_ig_rd.variants
for old, new in zip(old_variants, new_variants):
self.assertIsInstance(new, self.new_model.SmallVariant)
self.assertEqual(
new,
MigrateReports500To600()._migrate_variant((old, new))
)
for v in new_variants:
for re in v.reportEvents:
if re.genePanel is not None:
self.assertTrue(re.genePanel.source == 'panelapp')
def test_tiered_variant_inject_cancer_factory(self):
tiered_variant_inject_factory = GenericFactoryAvro.get_factory_avro(
cva_1_0_0.TieredVariantInjectCancer,
version=VERSION_61
)
instance = tiered_variant_inject_factory()
self.assertTrue(instance.validate(instance.toJsonDict()))
def test_migrate_clinical_report_rd(self, fill_nullables=True):
old_clinical_report_rd = GenericFactoryAvro.get_factory_avro(
self.old_model.ClinicalReportRD, VERSION_61, fill_nullables=fill_nullables
).create()
new_clinical_report = MigrateReports500To600().migrate_clinical_report_rd(
old_instance=old_clinical_report_rd
)
self._validate(new_clinical_report)
self.assertIsInstance(new_clinical_report, self.new_model.ClinicalReport)
attributes = [
"interpretationRequestId", "interpretationRequestVersion", "reportingDate", "user", "genomicInterpretation",
"referenceDatabasesVersions", "softwareVersions", "references"
]
for attribute in attributes:
if getattr(old_clinical_report_rd, attribute) is not None:
self.assertEqual(
getattr(old_clinical_report_rd, attribute),
getattr(new_clinical_report, attribute)
)
old_variants = old_clinical_report_rd.variants
if old_variants is not None:
new_variants = new_clinical_report.variants
for old, new in zip(old_variants, new_variants):
self.assertIsInstance(new, self.new_model.SmallVariant)
self._validate(new)
self.assertEqual(
new,
MigrateReports500To600()._migrate_variant((old, new))
)
if old_clinical_report_rd.additionalAnalysisPanels is not None:
for panel in new_clinical_report.additionalAnalysisPanels:
self.assertIsInstance(panel, self.new_model.AdditionalAnalysisPanel)
def test_custom_fields2(self):
# get an interpretation request RD for reports 4.2.0
version_control_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.ReportVersionControl,
version = VERSION_500
)
instance_vc = version_control_factory(gitVersionControl = "4.3.0-SNAPSHOT")
self.assertTrue(instance_vc.validate(instance_vc.toJsonDict()))
interpretation_request_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_4_2_0.InterpretationRequestRD,
version=VERSION_500
)
instance_ir = interpretation_request_factory(versionControl=instance_vc)
self.assertTrue(instance_ir.validate(instance_ir.toJsonDict()))
self.assertTrue(instance_ir.versionControl.gitVersionControl == "4.3.0-SNAPSHOT")
def test_migrate_rd_clinical_report_500_600(self, fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
reports_5_0_0.ClinicalReportRD,
VERSION_61,
fill_nullables=fill_nullables).create()
self._validate(old_instance)
if fill_nullables:
self._check_non_empty_fields(old_instance)
# Create a float_list of 5 floats and after casting to string assign to the fdp50 values of the old instance
# IF THE fdp50 VALUE HAS MORE THAN 11 DECIMAL PLACES THEN THE CONVERSION TO FLOAT WILL FAIL
float_list = [round(uniform(1.0, 10.0), 11) for _ in range(5)]
for index_value, variant in enumerate(old_instance.variants):
variant.variantAttributes.fdp50 = str(float_list[index_value])
migrated_instance = MigrationHelpers.migrate_clinical_report_rd_to_latest(
old_instance.toJsonDict())
self.assertIsInstance(migrated_instance, reports_6_0_0.ClinicalReport)
self._validate(migrated_instance)
if fill_nullables:
# Check that the fdp50 values have been correctly converted from string to float
for index_value, variant in enumerate(migrated_instance.variants):
self.assertEqual(variant.variantAttributes.fdp50,
float_list[index_value])
def test_migrate_reported_variant_with_consequence(self,
fill_nullables=True):
old_reported_variant = GenericFactoryAvro.get_factory_avro(
self.old_model.ReportedVariant,
VERSION_61,
fill_nullables=fill_nullables).create()
old_reported_variant.additionalTextualVariantAnnotations = {
'ConsequenceType':
"initiator_codon_variant,incomplete_terminal_codon_variant"
}
old_reported_variant.reportEvents[0].tier = self.old_model.Tier.TIER1
old_reported_variant.reportEvents[1].tier = self.old_model.Tier.TIER2
new_small_variant = BaseMigration.convert_class(
reports_6_0_0.SmallVariant, old_reported_variant)
new_small_variant = MigrateReports500To600()._migrate_variant(
(old_reported_variant, new_small_variant))
self._validate(new_small_variant)
self.assertIsInstance(new_small_variant, self.new_model.SmallVariant)
self.assertEqual(
len(new_small_variant.reportEvents[0].variantConsequences), 1)
self.assertTrue(
new_small_variant.reportEvents[0].variantConsequences[0].name ==
'initiator_codon_variant')
self.assertEqual(
len(new_small_variant.reportEvents[1].variantConsequences), 1)
self.assertTrue(
new_small_variant.reportEvents[1].variantConsequences[0].name ==
'incomplete_terminal_codon_variant')
def test_migrate_interpretation_request_cancer_to_interpreted_genome_400_600(
self, fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
reports_4_0_0.CancerInterpretationRequest,
VERSION_400,
fill_nullables=fill_nullables).create()
if not fill_nullables:
old_instance.cancerParticipant.LDPCode = "12345"
# only one tumour sample
old_instance.cancerParticipant.tumourSamples = old_instance.cancerParticipant.tumourSamples[
0:1]
self._validate(old_instance)
if fill_nullables:
self._check_non_empty_fields(old_instance)
migrated_instance = MigrationHelpers.migrate_interpretation_request_cancer_to_interpreted_genome_latest(
old_instance.toJsonDict(),
assembly='GRCh38',
interpretation_service='testing',
reference_database_versions={'thisdb': 'thatversion'},
software_versions={'testing': '1.2'},
report_url='fake.url',
comments=['blah', 'blah!', 'blah?'])
self.assertIsInstance(migrated_instance,
reports_6_0_0.InterpretedGenome)
self._validate(migrated_instance)
def setUp(self):
# avoids infinite recursion in mocked data
# now creates another factory generating values for nullable fields
file_factory = GenericFactoryAvro.get_factory_avro(
protocols.reports_3_0_0.File, VERSION_300, False, False)
GenericFactoryAvro.register_factory(protocols.reports_3_0_0.File,
file_factory, VERSION_300, True)
def test_migrate_rd_exit_questionnaire(self, fill_nullables=True):
# creates a random clinical report RD for testing filling null values
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.RareDiseaseExitQuestionnaire, VERSION_400, fill_nullables=fill_nullables
).create() # we need to enforce that it can be cast to int
self._validate(old_instance)
if fill_nullables:
self._check_non_empty_fields(old_instance)
new_instance = MigrateReports400To300().migrate_exit_questionnaire_rd(old_instance=old_instance)
self.assertIsInstance(new_instance, self.new_model.RareDiseaseExitQuestionnaire)
self._validate(new_instance)
camels = [vq.variantDetails for gq in old_instance.variantGroupLevelQuestions for vq in
gq.variantLevelQuestions]
snakes = [vq.variant_details for gq in new_instance.variantGroupLevelQuestions for vq in
gq.variantLevelQuestions]
for camel, snake in zip(camels, snakes):
self.assertEqual(camel, snake) # !!
camels = [gq.variantGroup for gq in old_instance.variantGroupLevelQuestions]
snakes = [gq.variant_group for gq in new_instance.variantGroupLevelQuestions]
for camel, snake in zip(camels, snakes):
self.assertEqual(camel, snake) # !!
def test_migrate_variant_call_to_called_genotype(self):
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.VariantCall, VERSION_61, fill_nullables=True
).create()
new_instance = MigrateReports500To400()._migrate_variant_call_to_called_genotype(variant_call=old_instance)
self.assertTrue(isinstance(new_instance, self.new_model.CalledGenotype))
self._validate(new_instance)
def test_migrate_rd_clinical_report_300_600(self, fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
reports_3_0_0.ClinicalReportRD, VERSION_300, fill_nullables=fill_nullables
).create()
old_instance.interpretationRequestVersion = str(factory.fuzzy.FuzzyInteger(0).fuzz())
self._validate(old_instance)
if fill_nullables:
for csv in old_instance.candidateStructuralVariants:
for cg in csv.calledGenotypes:
cg.copyNumber = int(round(uniform(-100, 100)))
cg.phaseSet = int(round(uniform(-100, 100)))
cg.depthReference = int(round(uniform(-100, 100)))
cg.depthAlternate = int(round(uniform(-100, 100)))
for cv in old_instance.candidateVariants:
for cg in cv.calledGenotypes:
cg.copyNumber = int(round(uniform(-100, 100)))
cg.phaseSet = int(round(uniform(-100, 100)))
cg.depthReference = int(round(uniform(-100, 100)))
cg.depthAlternate = int(round(uniform(-100, 100)))
self._check_non_empty_fields(old_instance)
migrated_instance = MigrationHelpers.migrate_clinical_report_rd_to_latest(
old_instance.toJsonDict(), assembly='GRCh38')
self.assertIsInstance(migrated_instance, reports_6_0_0.ClinicalReport)
self._validate(migrated_instance)
def test_migrate_rd_exit_questionnaire(self, fill_nullables=True):
old_rd_eq = GenericFactoryAvro.get_factory_avro(
self.old_model.RareDiseaseExitQuestionnaire,
VERSION_61,
fill_nullables=fill_nullables).create()
old_rd_eq = self.populate_exit_questionnaire_variant_details(
eq=old_rd_eq)
new_rd_eq = MigrateReports500To600().migrate_rd_exit_questionnaire(
old_instance=old_rd_eq, assembly="GRCh38")
self._validate(new_rd_eq)
self.assertIsInstance(new_rd_eq,
self.new_model.RareDiseaseExitQuestionnaire)
self.assertEqual(old_rd_eq.eventDate, new_rd_eq.eventDate)
self.assertEqual(old_rd_eq.reporter, new_rd_eq.reporter)
self.assertIsInstance(new_rd_eq.familyLevelQuestions,
self.new_model.FamilyLevelQuestions)
attributes = [
"caseSolvedFamily", "segregationQuestion", "additionalComments"
]
for attribute in attributes:
self.assertEqual(
getattr(old_rd_eq.familyLevelQuestions, attribute),
getattr(new_rd_eq.familyLevelQuestions, attribute),
)
for VGLQ in new_rd_eq.variantGroupLevelQuestions:
self.assertIsInstance(VGLQ,
self.new_model.VariantGroupLevelQuestions)
for VLQ in VGLQ.variantLevelQuestions:
self.assertIsInstance(VLQ,
self.new_model.VariantLevelQuestions)
def test_migrate_clinical_report_rd(self):
"""Also tested with real data"""
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.ClinicalReportRD, VERSION_210, fill_nullables=False
).create() # reports_3_0_0.InterpretationRequestRD
self._validate(old_instance)
migrated_instance = Migration21To3().migrate_clinical_report(
old_instance)
self._validate(migrated_instance)
old_instance = GenericFactoryAvro.get_factory_avro(
self.old_model.ClinicalReportRD, VERSION_210, fill_nullables=True
).create() # reports_3_0_0.InterpretationRequestRD
self._validate(old_instance)
migrated_instance = Migration21To3().migrate_clinical_report(
old_instance)
self._validate(migrated_instance)
def test_migrate_cancer_participant_110_110(self, fill_nullables=True):
old_instance = GenericFactoryAvro.get_factory_avro(
participant_1_0_3.CancerParticipant, VERSION_61, fill_nullables=fill_nullables
).create()
self._validate(old_instance)
if fill_nullables:
self._check_non_empty_fields(old_instance)
migrated_instance = MigrationHelpers.migrate_cancer_participant_to_latest(old_instance.toJsonDict())
self._validate(migrated_instance)
