def test_add_member_genes(self):
net = NiceCXNetwork()
aid = net.create_node('a')
net.set_node_attribute(aid, NodeMemberUpdator.TYPE, 'proteinfamily')
notinid = net.create_node('x')
net.set_node_attribute(notinid, NodeMemberUpdator.TYPE,
'proteinfamily')
mock = GeneSymbolSearcher(bclient=None)
mock.get_symbol = MagicMock(side_effect=['', None])
updator = NodeMemberUpdator(None, None, genesearcher=mock)
aidnode = net.get_node(aid)
res = updator._add_member_genes(net, aidnode, [])
self.assertEqual(['No proteins obtained for node: ' + str(aidnode)],
res)
notinidnode = net.get_node(notinid)
res = updator._add_member_genes(net, notinidnode, ['x'])
self.assertTrue('For node ' + str(notinidnode) +
' No gene symbol found for x. Skipping.' in res)
self.assertTrue('Not a single gene symbol found. Skipping insertion '
'of member attribute for node ' +
str(notinidnode) in res)
def test_set_node_attribute_passing_empty_dict(self):
# try int
net = NiceCXNetwork()
try:
net.set_node_attribute({}, 'attrname', 5)
self.fail('Expected NDExError')
except NDExError as ne:
self.assertEqual(str(ne), 'No id found in Node')
def test_set_node_attribute_passing_node_object(self):
# try int
net = NiceCXNetwork()
node_id = net.create_node(node_name='foo')
node = net.get_node(node_id)
net.set_node_attribute(node, 'attrname', 5)
res = net.get_node_attributes(node_id)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], node_id)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 5)
self.assertEqual(res[0][constants.NODE_ATTR_DATATYPE], 'integer')
def test_set_node_attribute_none_values(self):
net = NiceCXNetwork()
try:
net.set_node_attribute(None, 'foo', 'blah')
self.fail('Expected exception')
except NDExError as ne:
self.assertEqual(str(ne), 'Node attribute requires property_of')
try:
net.set_node_attribute('hi', None, 'blah')
self.fail('Expected exception')
except NDExError as ne:
self.assertEqual(str(ne), 'Node attribute requires the name and '
'values property')
def test_set_node_attribute_empty_add_overwrite_toggled(self):
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 'value')
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 'value')
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 1, type='double')
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 1)
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 'value', overwrite=True)
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 'value')
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 1, type='double',
overwrite=True)
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 1)
def test_set_node_attribute_add_duplicate_attributes_overwriteset(self):
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 'value', overwrite=True)
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 'value')
net.set_node_attribute(1, 'attrname', 'value2', overwrite=True)
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 'value2')
def test_update_network_containing_all_types(self):
pfdict = {'a': ['2', '3'], 'SIGNOR-PF10': ['7', '8']}
cdict = {'e': ['5', '6'], 'SIGNOR-C1': ['9', '10']}
net = NiceCXNetwork()
aid = net.create_node('a')
net.set_node_attribute(aid, NodeMemberUpdator.TYPE, 'proteinfamily')
eid = net.create_node('e')
net.set_node_attribute(eid, NodeMemberUpdator.TYPE, 'complex')
oid = net.create_node('c')
o2id = net.create_node('d')
net.set_node_attribute(o2id, NodeMemberUpdator.TYPE, 'protein')
notinid = net.create_node('x')
net.set_node_attribute(notinid, NodeMemberUpdator.TYPE,
'proteinfamily')
notinid2 = net.create_node('y')
net.set_node_attribute(notinid2, NodeMemberUpdator.TYPE, 'complex')
mock = GeneSymbolSearcher(bclient=None)
mock.get_symbol = MagicMock(side_effect=['AA', 'BB', 'CC', 'DD'])
updator = NodeMemberUpdator(pfdict, cdict, genesearcher=mock)
res = updator.update(net)
self.assertTrue(
"No entry in proteinfamily map for node: {'@id': 4, 'n': 'x', 'r': 'x'}"
in res)
self.assertTrue(
"No entry in complexes map for node: {'@id': 5, 'n': 'y', 'r': 'y'}"
in res)
res = net.get_node_attribute(aid, NodeMemberUpdator.MEMBER)
self.assertTrue('hgnc.symbol:AA' in res['v'])
self.assertTrue('hgnc.symbol:BB' in res['v'])
res = net.get_node_attribute(eid, NodeMemberUpdator.MEMBER)
self.assertTrue('hgnc.symbol:CC' in res['v'])
self.assertTrue('hgnc.symbol:DD' in res['v'])
res = net.get_node_attribute(oid, NodeMemberUpdator.MEMBER)
self.assertEqual(None, res)
res = net.get_node_attribute(o2id, NodeMemberUpdator.MEMBER)
self.assertEqual(None, res)
def test_remove_node_from_network_with_edges_and_attrs(self):
net = NiceCXNetwork()
node_id = net.create_node('node1', node_represents='ha')
other_node_id = net.create_node('node2', node_represents='ha')
edge_id = net.create_edge(edge_source=node_id,
edge_target=other_node_id,
edge_interaction='activates')
net.set_node_attribute(node_id, 'nodeattr', values='foo')
net.set_node_attribute(node_id, 'nodeattr2', values='foo2')
net.set_edge_attribute(edge_id, 'edgeattr', values='hello')
net.set_edge_attribute(edge_id, 'edgeattr2', values='hello2')
nef = NetworkNodeFactory()
nn = nef.get_network_node_from_network(net_cx=net, node_id=node_id)
nn.remove_node_from_network(net_cx=net)
self.assertEqual(1, len(net.get_nodes()))
self.assertEqual(0, len(net.get_edges()))
def test_set_node_attribute_empty_add_autodetect_datatype(self):
# try int
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 5)
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 5)
self.assertEqual(res[0][constants.NODE_ATTR_DATATYPE], 'integer')
# try double/float
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', 5.5)
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], 5.5)
self.assertEqual(res[0][constants.NODE_ATTR_DATATYPE], 'double')
# try list of string
net = NiceCXNetwork()
net.set_node_attribute(1, 'attrname', ['hi', 'bye'])
res = net.get_node_attributes(1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[0][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[0][constants.NODE_ATTR_VALUE], ['hi', 'bye'])
self.assertEqual(res[0][constants.NODE_ATTR_DATATYPE],
'list_of_string')
def test_update_network_containing_all_types(self):
updator = UpdatePrefixesForNodeRepresents()
net = NiceCXNetwork()
uni_one = net.create_node('somenode', node_represents='rep1')
net.set_node_attribute(uni_one, 'DATABASE', 'UNIPROT')
uni_two = net.create_node('somenode2', node_represents='uniprot:rep2')
net.set_node_attribute(uni_two, 'DATABASE', 'UNIPROT')
sig_one = net.create_node('somenode3', node_represents='rep3')
net.set_node_attribute(sig_one, 'DATABASE', 'SIGNOR')
sig_two = net.create_node('somenode4', node_represents='signor:rep4')
net.set_node_attribute(sig_two, 'DATABASE', 'SIGNOR')
other = net.create_node('somenode5', node_represents='blah:rep5')
net.set_node_attribute(other, 'DATABASE', 'other')
self.assertEqual([], updator.update(net))
res = net.get_node(uni_one)
self.assertEqual('uniprot:rep1', res['r'])
self.assertEqual(None, net.get_node_attribute(uni_one, 'DATABASE'))
res = net.get_node(uni_two)
self.assertEqual('uniprot:rep2', res['r'])
self.assertEqual(None, net.get_node_attribute(uni_two, 'DATABASE'))
res = net.get_node(sig_one)
self.assertEqual('signor:rep3', res['r'])
self.assertEqual(None, net.get_node_attribute(sig_one, 'DATABASE'))
res = net.get_node(sig_two)
self.assertEqual('signor:rep4', res['r'])
self.assertEqual(None, net.get_node_attribute(sig_two, 'DATABASE'))
res = net.get_node(other)
self.assertEqual('blah:rep5', res['r'])
self.assertEqual(None, net.get_node_attribute(other, 'DATABASE'))
def test_update_network_containing_all_types(self):
updator = SpringLayoutUpdator()
net = NiceCXNetwork()
comp_attr = NodeLocationUpdator.LOCATION
ecnode = net.create_node(node_name='ecnode', node_represents='ecnoder')
net.set_node_attribute(ecnode, comp_attr,
SpringLayoutUpdator.EXTRACELLULAR)
rnode = net.create_node(node_name='rnode', node_represents='rnoder')
net.set_node_attribute(rnode, comp_attr,
SpringLayoutUpdator.RECEPTOR)
cnode = net.create_node(node_name='cnode', node_represents='cnoder')
net.set_node_attribute(cnode, comp_attr,
SpringLayoutUpdator.CYTOPLASM)
fnode = net.create_node(node_name='fnode', node_represents='fnoder')
net.set_node_attribute(fnode, comp_attr,
SpringLayoutUpdator.FACTOR)
pnode = net.create_node(node_name='pnode', node_represents='pnoder')
net.set_node_attribute(pnode, comp_attr,
SpringLayoutUpdator.PHENOTYPESLIST)
xnode = net.create_node(node_name='xnode', node_represents='xnoder')
self.assertEqual([], updator.update(net))
res = net.get_opaque_aspect(SpringLayoutUpdator.CARTESIAN_LAYOUT)
ydict = {}
for entry in res:
ydict[entry['node']] = entry['y']
self.assertTrue(ydict[ecnode] < 0.0)
self.assertTrue(ydict[rnode] < 0.0)
self.assertTrue(ydict[cnode] > -100.0)
self.assertTrue(ydict[fnode] > 0.0)
self.assertTrue(ydict[pnode] > 0.0)
def test_update_network_containing_all_types(self):
updator = NodeLocationUpdator()
net = NiceCXNetwork()
comp_attr = NodeLocationUpdator.LOCATION
no_attr = net.create_node('somenode', node_represents='rep1')
e_attr = net.create_node('somenode2', node_represents='uniprot:rep2')
net.set_node_attribute(e_attr, NodeLocationUpdator.LOCATION, '')
o_attr = net.create_node('somenode2', node_represents='uniprot:rep2')
net.set_node_attribute(o_attr, NodeLocationUpdator.LOCATION, 'blah')
self.assertEqual([], updator.update(net))
self.assertEqual(NodeLocationUpdator.CYTOPLASM,
net.get_node_attribute(no_attr, comp_attr)['v'])
self.assertEqual(NodeLocationUpdator.CYTOPLASM,
net.get_node_attribute(e_attr, comp_attr)['v'])
self.assertEqual('blah',
net.get_node_attribute(o_attr, comp_attr)['v'])
node_id_list.append(node_id)
print(node_id_list)
# #### add_node(node)
# In[ ]:
#This method has been deprecated. Please use create_node()
# #### set_node_attribute(node, attribute_name, values, type=None, subnetwork=None)
# In[ ]:
NiceCX_creatures = NiceCXNetwork()
node_id = NiceCX_creatures.create_node("new node")
NiceCX_creatures.set_node_attribute(node_id, "new attribute",
"new attribute value is xxxx")
# #### *add_node_attribute(node, attribute_name, values)
# In[ ]:
NiceCX_creatures = NiceCXNetwork()
node_id = NiceCX_creatures.create_node("new node")
NiceCX_creatures.add_node_attribute(node_id, "new attribute",
"new attribute value is xxxx")
# #### get_node_attribute(node, attribute_name, subnetwork=None)
# In[ ]:
NiceCX_creatures = NiceCXNetwork()
def test_one_node_network(self):
net = NiceCXNetwork()
node_one = net.create_node('first')
net.set_node_attribute(node_one,
'booleanattrib',
'false',
type='boolean')
net.set_node_attribute(node_one, 'integerattrib', '1', type='integer')
net.set_node_attribute(node_one, 'doubleattrib', '2.0', type='double')
net.set_node_attribute(node_one, 'longattrib', '3', type='long')
net.set_node_attribute(node_one,
'stringattrib',
'false',
type='string')
net.set_node_attribute(node_one,
'list_of_booleanattrib', ['True'],
type='list_of_boolean')
net.set_node_attribute(node_one,
'list_of_doubleattrib', ['4.0'],
type='list_of_double')
net.set_node_attribute(node_one,
'list_of_integerattrib', ['5'],
type='list_of_integer')
net.set_node_attribute(node_one,
'list_of_longattrib', ['6'],
type='list_of_long')
net.set_node_attribute(node_one,
'list_of_stringattrib', ['false'],
type='list_of_string')
net.set_name('bob')
fac = DefaultNetworkXFactory()
g = fac.get_graph(net)
self.assertEqual('bob', g.graph['name'])
self.assertEqual(1, len(g))
self.assertEqual(0, g.number_of_edges())
self.assertTrue(0 in g)
if NETWORKX_MAJOR_VERSION >= 2:
nodelist = list(g.nodes(data=True))
else:
nodelist = g.nodes(data=True)
self.assertEqual('false', nodelist[0][1]['booleanattrib'])
self.assertEqual('1', nodelist[0][1]['integerattrib'])
self.assertEqual('2.0', nodelist[0][1]['doubleattrib'])
self.assertEqual('3', nodelist[0][1]['longattrib'])
self.assertEqual('false', nodelist[0][1]['stringattrib'])
self.assertEqual(['True'], nodelist[0][1]['list_of_booleanattrib'])
self.assertEqual(['4.0'], nodelist[0][1]['list_of_doubleattrib'])
self.assertEqual(['5'], nodelist[0][1]['list_of_integerattrib'])
self.assertEqual(['6'], nodelist[0][1]['list_of_longattrib'])
self.assertEqual(['false'], nodelist[0][1]['list_of_stringattrib'])
