def update_orders_dict_using_additional_data_dict(self, order_data_dict, additional_data_keys, additional_data_dict):
if order_data_dict:
self.data_dict_sanity_check(order_data_dict, treat_data_dict_as='layer_orders')
self.data_dict_sanity_check(additional_data_dict, data_keys_list=additional_data_keys, treat_data_dict_as='layers')
# FIXME: here we need to check whether the two dictionaries are in fact 'compatible' with respect to sample names
# they describe.
for data_key in additional_data_keys:
if '!' in data_key:
# we don't order stacked bar charts
continue
# predict the type for proper assignment of 'null' values
if '!' in data_key:
predicted_key_type = "stackedbar"
else:
type_class = utils.get_predicted_type_of_items_in_a_dict(additional_data_dict, data_key)
predicted_key_type = type_class.__name__ if type_class else 'unknown'
layer_name_layer_data_tuples = [(additional_data_dict[layer][data_key] if additional_data_dict[layer][data_key] else self.nulls_per_type[predicted_key_type], layer) for layer in additional_data_dict]
order_data_dict['>> ' + data_key] = {'newick': None, 'basic': ','.join([t[1] for t in sorted(layer_name_layer_data_tuples)])}
order_data_dict['>> ' + data_key + ' (reverse)'] = {'newick': None, 'basic': ','.join([t[1] for t in sorted(layer_name_layer_data_tuples, reverse=True)])}
return order_data_dict
def add(self, data_dict, data_keys_list, skip_check_names=False):
key_types = {}
for key in data_keys_list:
if '!' in key:
predicted_key_type = "stackedbar"
else:
type_class = utils.get_predicted_type_of_items_in_a_dict(
data_dict, key)
predicted_key_type = type_class.__name__ if type_class else None
key_types[key] = predicted_key_type
db_entries = []
self.set_next_available_id(self.table_name)
for item_name in data_dict:
for key in data_dict[item_name]:
db_entries.append(
tuple([
self.next_id(self.table_name), item_name, key,
data_dict[item_name][key], key_types[key]
]))
database = db.DB(self.db_path, None, ignore_version=True)
database._exec_many(
'''INSERT INTO %s VALUES (?,?,?,?,?)''' % self.table_name,
db_entries)
database.disconnect()
def add(self, keys_list, data_dict, skip_check_names=False):
if not isinstance(keys_list, list):
raise ConfigError("List of keys must be of type `list`. Go away.")
if not isinstance(data_dict, dict):
raise ConfigError("Nope. Your data must be of type `dict`.")
self.run.warning(None, 'New additional data...', lc="yellow")
key_types = {}
for key in keys_list:
if '!' in key:
predicted_key_type = "stackedbar"
else:
type_class = utils.get_predicted_type_of_items_in_a_dict(data_dict, key)
predicted_key_type = type_class.__name__ if type_class else None
key_types[key] = predicted_key_type
self.run.info('Key "%s"' % key, 'Predicted type: %s' % (key_types[key]), \
nl_after = 1 if key == keys_list[-1] else 0)
db_entries = []
self.set_next_available_id(self.table_name)
for item_name in data_dict:
for key in data_dict[item_name]:
db_entries.append(tuple([self.next_id(self.table_name),
item_name,
key,
data_dict[item_name][key],
key_types[key]]))
database = db.DB(self.db_path, None, ignore_version=True)
database._exec_many('''INSERT INTO %s VALUES (?,?,?,?,?)''' % self.table_name, db_entries)
database.disconnect()
self.run.info('New data added to the db', '%s.' % (', '.join(keys_list)))
def auto_order_items_based_on_additional_layers_data(self):
if self.skip_auto_ordering:
return
self.progress.new(
'Processing additional layer data for ordering of splits (to skip: --skip-auto-ordering)'
)
# go through additional layers that are not of type `bar`.
for layer in [
additional_layer
for additional_layer in self.additional_layers_headers
if '!' not in additional_layer
]:
self.progress.update('for "%s" ...' % layer)
layer_type = utils.get_predicted_type_of_items_in_a_dict(
self.additional_layers_dict, layer)
item_layer_data_tuple = [
(layer_type(self.additional_layers_dict[item][layer]), item)
for item in self.additional_layers_dict
]
self.p_meta['available_clusterings'].append('>> %s:none:none' %
layer)
self.p_meta['clusterings']['>> %s' % layer] = {
'basic': [i[1] for i in sorted(item_layer_data_tuple)]
}
self.p_meta['available_clusterings'].append(
'>> %s_(reverse):none:none' % layer)
self.p_meta['clusterings']['>> %s_(reverse)' % layer] = {
'basic':
[i[1] for i in sorted(item_layer_data_tuple, reverse=True)]
}
self.progress.end()
def add(self, keys_list, data_dict, skip_check_names=False):
if not isinstance(keys_list, list):
raise ConfigError("List of keys must be of type `list`. Go away.")
if not isinstance(data_dict, dict):
raise ConfigError("Nope. Your data must be of type `dict`.")
self.run.warning(None, 'New additional data...', lc="yellow")
key_types = {}
for key in keys_list:
if '!' in key:
predicted_key_type = "stackedbar"
else:
type_class = utils.get_predicted_type_of_items_in_a_dict(
data_dict, key)
predicted_key_type = type_class.__name__ if type_class else None
key_types[key] = predicted_key_type
self.run.info('Key "%s"' % key, 'Predicted type: %s' % (key_types[key]), \
nl_after = 1 if key == keys_list[-1] else 0)
db_entries = []
self.set_next_available_id(self.table_name)
for item_name in data_dict:
for key in data_dict[item_name]:
db_entries.append(
tuple([
self.next_id(self.table_name), item_name, key,
data_dict[item_name][key], key_types[key]
]))
database = db.DB(self.db_path, None, ignore_version=True)
database._exec_many(
'''INSERT INTO %s VALUES (?,?,?,?,?)''' % self.table_name,
db_entries)
database.disconnect()
self.run.info('New data added to the db',
'%s.' % (', '.join(keys_list)))
def add(self, data_dict, data_keys_list, skip_check_names=False):
key_types = {}
for key in data_keys_list:
if '!' in key:
predicted_key_type = "stackedbar"
else:
type_class = utils.get_predicted_type_of_items_in_a_dict(data_dict, key)
predicted_key_type = type_class.__name__ if type_class else None
key_types[key] = predicted_key_type
db_entries = []
self.set_next_available_id(self.table_name)
for item_name in data_dict:
for key in data_dict[item_name]:
db_entries.append(tuple([self.next_id(self.table_name),
item_name,
key,
data_dict[item_name][key],
key_types[key]]))
database = db.DB(self.db_path, None, ignore_version=True)
database._exec_many('''INSERT INTO %s VALUES (?,?,?,?,?)''' % self.table_name, db_entries)
database.disconnect()
def add(self, data_dict, data_keys_list, skip_check_names=False, data_group="default"):
"""Function to add data into the item additional data table.
* `data_dict`: a dictionary for items or layers additional should follow this format:
d = {
'item_or_layer_name_01': {'data_key_01': value,
'data_key_02': value,
'data_key_03': value
},
'item_or_layer_name_02': {'data_key_01': value,
'data_key_03': value,
},
(...)
}
* `data_keys_list`: is a list of keys one or more of which should appear for each item
in `data_dict`.
"""
self.data_dict_sanity_check(data_dict, data_keys_list=data_keys_list)
if self.target not in ['items', 'layers']:
raise ConfigError("You are using an AdditionalDataBaseClass instance to add %s data into your %s database. But\
you know what? You can't do that :/ Someone made a mistake somewhere. If you are a user,\
check your flags to make sure you are targeting the right data table. If you are a programmer,\
you are fired." % (self.target, self.db_type))
self.run.warning(None, 'New %s additional data...' % self.target, lc="yellow")
key_types = {}
for key in data_keys_list:
if '!' in key:
predicted_key_type = "stackedbar"
else:
type_class = utils.get_predicted_type_of_items_in_a_dict(data_dict, key)
predicted_key_type = type_class.__name__ if type_class else None
key_types[key] = predicted_key_type
self.run.info('Data key "%s"' % key, 'Predicted type: %s' % (key_types[key]), \
nl_after = 1 if key == data_keys_list[-1] else 0)
# we be responsible here.
database = db.DB(self.db_path, utils.get_required_version_for_db(self.db_path))
all_keys_for_group = database.get_single_column_from_table(self.table_name,
'data_key', unique=True, where_clause="""'data_group' LIKE '%s'""" % data_group)
database.disconnect()
keys_already_in_db = [c for c in data_keys_list if c in all_keys_for_group]
if len(keys_already_in_db):
if self.just_do_it:
self.run.warning('The following keys in your data dict will replace the ones that are already\
in your %s database: %s.' % (self.db_type, ', '.join(keys_already_in_db)))
self.remove(keys_already_in_db)
else:
run.info('Data keys already in the db', ', '.join(keys_already_in_db), nl_before=2, mc='red')
raise ConfigError("Some of the data keys in your new data appear to be in the database already. If you\
want to replace those in the database with the ones in your new data use the\
`--just-do-it` flag, and watch anvi'o make an exception just for you and complain\
about nothin' for this once.")
if skip_check_names:
self.run.warning("You (or the programmer) asked anvi'o to NOT check the consistency of the names of your %s\
between your additional data and the %s database you are attempting to update. So be it.\
Anvi'o will not check anything, but if things don't look the way you expected them to look,\
you will not blame anvi'o for your poorly prepared data, but choose between yourself or\
Obama." % (self.target, self.db_type))
else:
if self.target == 'layers':
TableForLayerAdditionalData.check_names(self, data_dict)
elif self.target == 'items':
TableForItemAdditionalData.check_names(self, data_dict)
else:
raise ConfigError("Congratulations, you managed to hit an uncharted are in anvi'o. It is cerrtainly very\
curious how you got here unless you are trying to implement a new functionality.")
db_entries = []
self.set_next_available_id(self.table_name)
for item_name in data_dict:
for key in data_keys_list:
db_entries.append(tuple([self.next_id(self.table_name),
item_name,
key,
data_dict[item_name][key],
key_types[key],
data_group]))
database = db.DB(self.db_path, utils.get_required_version_for_db(self.db_path))
database._exec_many('''INSERT INTO %s VALUES (?,?,?,?,?,?)''' % self.table_name, db_entries)
database.disconnect()
self.run.info('New data added to the db for your %s' % self.target, '%s.' % (', '.join(data_keys_list)), nl_after=1)
