Esempio n. 1
0
 def setUp(self):
     input_file = os.path.join(INPUT_PATH, "cases", "normal.json")
     loaded_correct = json.NewJson.from_file(input_file)
     self.case = case.Case(loaded_correct)
     self.phenomizer = phenomizer.PhenomizerService(config=CONFIG)
     self.omim_obj = omim.Omim(api_key=CONFIG.omim['api_key'],
                               mimdir=INPUT_PATH,
                               use_cached=False)
Esempio n. 2
0
def main():
    '''Query list of phenotypic omim ids'''

    config_data = config.ConfigManager("config.ini")
    omim_internal = omim.Omim(config=config_data)

    r = omim_internal.construct_phenotypic_series_mapping()
    print(r)
Esempio n. 3
0
def create_cases(args, config_data, jsons):
    print("== Create cases from new json format ==")
    error_fixer = errorfixer.ErrorFixer(config=config_data)
    omim_obj = omim.Omim(config=config_data)
    case_objs = yield_cases(jsons, error_fixer, omim_obj,
                            config_data.preprocess["exclude_normal_variants"])

    mutalyzer.correct_reference_transcripts(case_objs)

    if config_data.general['dump_intermediate'] and not args.single:
        pickle.dump(case_objs, open('case_cleaned.p', 'wb'))

    return case_objs
Esempio n. 4
0
    def setUpClass(cls):
        super().setUpClass()
        cls.error_fixer = errorfixer.ErrorFixer(config=cls.config,
                                                version=ERROR_VERSION)

        cls.omim = omim.Omim(config=cls.config)
Esempio n. 5
0
 def test_init(self):
     omim_obj = omim.Omim(mimdir=self.input_path)
     self.assertIsNotNone(omim_obj)
Esempio n. 6
0
 def setUpClass(cls):
     super().setUpClass()
     cls.omim = omim.Omim(mimdir=cls.input_path)
Esempio n. 7
0
def get_qc_cases(config_data, cases):
    '''Get qc results for all cases.'''
    omim_obj = omim.Omim(config=config_data)
    return {c.case_id: (c.check(omim_obj), c) for c in cases}
Esempio n. 8
0
def convert_to_old_format(args, config_data, cases):
    print("== Mapping to old json format ==")
    destination = args.output or config_data.conversion["output_path"]

    omim_obj = omim.Omim(config=config_data)
    return yield_old_json(cases, destination, omim_obj)
Esempio n. 9
0
    }

    # cases have to pass vcf check
    qc_passed = {
        case_id: case
        for case_id, case in qc_passed.items() if qc_vcf[case_id][0]
    }

    # Cases with mutations marked as benign excluded from analysis
    qc_benign_passed = {
        k: v
        for k, v in {k: v.get_benign_excluded()
                     for k, v in qc_passed.items()}.items() if v > 0
    }

    omim_obj = omim.Omim(config=config_data)

    # Cases where pathogenic diagnosed mutation is not in geneList
    @progress_bar("Get pathogenic genes in geneList")
    def pathogenic_genes_process(cases):
        for case_id, case_obj in cases.items():
            yield case_id, case_obj.pathogenic_gene_in_gene_list(omim_obj)

    qc_pathongenic_passed = dict(c for c in pathogenic_genes_process(qc_passed)
                                 if not c[1][0])

    # Compiled stats to be dumped into a json file
    qc_output = {
        "failed": qc_failed_msg,
        "benign_excluded": qc_benign_passed,
        "pathogenic_missing": qc_pathongenic_passed,
Esempio n. 10
0
from lib.api import mutalyzer, jannovar, omim, phenomizer, aws_download, lab
from lib import errorfixer

MUTALYZER_INST = mutalyzer.Mutalyzer()

JANNOVAR_INST = jannovar.JannovarClient()

OMIM_INST = omim.Omim()

PHENOMIZER_INST = phenomizer.PhenomizerService()

ERRORFIXER_INST = errorfixer.ErrorFixer()

AWS_INST = aws_download.AWSBucket()

LAB_INST = lab.Lab()