def get_available_criterias(cls, feature=None, config=None, test=False):
''' function to get avalable criterias for a given feature
@type feature: string
@param feature: feature type, could be 'gene','region', 'marker' etc.,
@type config: string
@keyword config: The config object initialized from criteria.ini.
'''
if config is None:
if test:
config = CriteriaManager.get_criteria_config(ini_file='test_criteria.ini')
else:
config = CriteriaManager.get_criteria_config(ini_file='criteria.ini')
criteria_dict = dict()
criteria_list = []
for section_name in config.sections():
if config[section_name] is not None:
section_config = config[section_name]
if 'feature' in section_config:
if feature is not None and feature != section_config['feature']:
continue
if section_config['feature'] in criteria_dict:
criteria_list = criteria_dict[section_config['feature']]
criteria_list.append(section_name)
else:
criteria_list = []
criteria_list.append(section_name)
criteria_dict[section_config['feature']] = criteria_list
return criteria_dict
def test_process_criterias(self):
feature = "gene"
criteria = "cand_gene_in_study,gene_in_region"
criteria_list = CriteriaManager.process_criterias(feature, criteria=None, config=None, show=True)
self.assertIn("cand_gene_in_study", criteria_list, "cand_gene_in_study in list")
self.assertIn("is_gene_in_mhc", criteria_list, "is_gene_in_mhc in list")
criteria_list = CriteriaManager.process_criterias(feature, criteria=criteria, config=None, show=True)
self.assertIn("cand_gene_in_study", criteria_list, "cand_gene_in_study in list")
self.assertNotIn("is_gene_in_mhc", criteria_list, "is_gene_in_mhc not in in list")
def test_get_criteria_config(self):
criteria_config = CriteriaManager.get_criteria_config()
self.assertIsNotNone(criteria_config, "config is not None")
section_config = criteria_config["cand_gene_in_study"]
self.assertIsNotNone(section_config, "section is not None")
self.assertEqual(section_config["feature"], "gene", "Got the right feature")
self.assertIsNotNone(section_config["desc"], "Desc is not none")
def test_tag_feature_to_all_diseases(self):
config = IniParser().read_ini(MY_INI_FILE)
section = "is_gene_in_mhc"
feature_id = 'ENSG00000229281'
result = Criteria.tag_feature_to_all_diseases(feature_id, section, config, {})
result_diseases = sorted(list(result['ENSG00000229281'].keys()))
(core_disease, other_disease) = CriteriaManager.get_available_diseases()
available_diseases = sorted(core_disease + other_disease)
self.assertEqual(result_diseases, available_diseases)
section = "is_marker_in_mhc"
feature_id = 'rs6679677'
result = Criteria.tag_feature_to_all_diseases(feature_id, section, config, {})
result_diseases = sorted(list(result['rs6679677'].keys()))
(core_disease, other_disease) = CriteriaManager.get_available_diseases()
available_diseases = sorted(core_disease + other_disease)
self.assertEqual(result_diseases, available_diseases)
def test_get_available_diseases(self):
(main, other) = utils.Disease.get_site_diseases()
self.assertEqual(12, len(main), "12 main diseases found when searching for all diseases")
self.assertEqual(8, len(other), "8 other diseases found when searching for all diseases")
(main_dis_code, other_dis_code) = CriteriaManager.get_available_diseases()
self.assertIn("T1D", main_dis_code)
self.assertIn("AA", other_dis_code)
def get_available_criterias(cls, feature=None, config=None):
'Function to get available criterias for region'
if config is None:
config = CriteriaManager.get_criteria_config()
if feature is None:
feature = cls.FEATURE_TYPE
available_criterias = Criteria.get_available_criterias(feature, config)
return available_criterias
def handle(self, *args, **options):
criteria_manager = CriteriaManager()
feature_ = None
criteria_ = None
if 'feature' in options:
feature_ = options['feature']
if 'criteria' in options:
criteria_ = options['criteria']
if 'show' in options:
show_ = options['show']
if 'test' in options:
test_ = options['test']
if test_:
config_ = criteria_manager.get_criteria_config(ini_file='test_criteria.ini')
else:
config_ = criteria_manager.get_criteria_config(ini_file='criteria.ini')
criteria_manager.process_criterias(feature=feature_, criteria=criteria_, config=config_, show=show_, test=test_)
def test_criteria_mappings(self, idx, idx_types):
(main_codes, other_codes) = CriteriaManager.get_available_diseases()
site_enabled_diseases = main_codes + other_codes
elastic_url = ElasticSettings.url()
for idx_type in idx_types:
url = idx + '/' + idx_type + '/_mapping'
response = Search.elastic_request(elastic_url, url, is_post=False)
elastic_type_mapping = json.loads(response.content.decode("utf-8"))
property_keys = list(elastic_type_mapping[idx]['mappings'][idx_type]['properties'].keys())
'''check if score and disease_tags and qid are there in mapping'''
self.assertIn('score', property_keys)
self.assertIn('disease_tags', property_keys)
self.assertIn('qid', property_keys)
'''check if all the enabled diseases are there'''
for disease in site_enabled_diseases:
self.assertIn(disease, property_keys)
def get_link_info(cls, idx, criteria_list):
link_info = {}
criteria_config = CriteriaManager.get_criteria_config()
for criteria in criteria_list:
criteria_section = criteria_config[criteria]
if idx not in link_info:
link_info[idx] = {}
if 'link_to_feature' in criteria_section:
link_to_feature = criteria_section['link_to_feature']
link_info[idx][criteria] = link_to_feature
return link_info
def create_criteria_mapping(cls, idx, idx_type, test_mode=False):
''' function to create mapping for criteria indexes
@type idx: string
@param idx: name of the index
@type idx_type: string
@param idx_type: name of the idx type, each criteria is an index type
@type test_mode: string
@param test_mode: flag to create or not create the mapping
'''
logger.warning('Idx ' + idx)
logger.warning('Idx_type ' + idx_type)
''' Create the mapping for alias indexing '''
props = MappingProperties(idx_type)
props.add_property("score", "integer")
props.add_property("disease_tags", "string", index="not_analyzed")
props.add_property("qid", "string", index="not_analyzed")
(main_codes, other_codes) = CriteriaManager().get_available_diseases()
for disease in main_codes + other_codes:
criteria_tags = MappingProperties(disease)
criteria_tags.add_property("fid", "string", index="not_analyzed")
criteria_tags.add_property("fname", "string", index="not_analyzed")
fnotes = MappingProperties('fnotes')
fnotes.add_property('linkid', "string", index="not_analyzed")
fnotes.add_property('linkname', "string", index="not_analyzed")
fnotes.add_property('linkdata', "string", index="not_analyzed")
fnotes.add_property('linkvalue', "string", index="not_analyzed")
criteria_tags.add_properties(fnotes)
props.add_properties(criteria_tags)
''' create index and add mapping '''
load = Loader()
options = {"indexName": idx, "shards": 5}
'''add meta info'''
config = CriteriaManager.get_criteria_config()
idx_type_cfg = config[idx_type]
desc = idx_type_cfg['desc']
meta = {"desc": desc}
if not test_mode:
load.mapping(props, idx_type, meta=meta, analyzer=Loader.KEYWORD_ANALYZER, **options)
return props
