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_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_wasderivedfrom(self):
fargs = FakeArgs()
fargs.conf = 'hi'
fargs.profile = 'profile'
fargs.datadir = '/foo'
fargs.visibility = 'PUBLIC'
loader = LoadSignorIntoNDEx(fargs, None)
net = NiceCXNetwork()
loader._set_wasderivedfrom(net, 'foo')
res = net.get_network_attribute(ndexloadsignor.DERIVED_FROM_ATTRIB)
self.assertEqual(
'https://signor.uniroma2.it/pathway_browser.php?'
'organism=&pathway_list=foo', res['v'])
# try with is_full_pathway false
net = NiceCXNetwork()
loader._set_wasderivedfrom(net, 'foo', is_full_pathway=False)
res = net.get_network_attribute(ndexloadsignor.DERIVED_FROM_ATTRIB)
self.assertEqual(
'https://signor.uniroma2.it/pathway_browser.php?'
'organism=&pathway_list=foo', res['v'])
# try with is_full_pathway true
net = NiceCXNetwork()
loader._set_wasderivedfrom(net, 'foo', is_full_pathway=True)
res = net.get_network_attribute(ndexloadsignor.DERIVED_FROM_ATTRIB)
self.assertEqual('https://signor.uniroma2.it', res['v'])
def test_update_network_with_empty_network(self):
client = self.get_ndex2_client()
# create network and add it
net = NiceCXNetwork()
oneid = net.create_node('node1')
twoid = net.create_node('node2')
net.create_edge(oneid, twoid, 'hello')
netname = 'NiceCXNetwork upload_to() test network' + str(
datetime.now())
net.set_name(netname)
creds = self.get_ndex_credentials_as_tuple()
res = net.upload_to(creds['server'],
creds['user'],
creds['password'],
user_agent=creds['user_agent'])
try:
self.assertTrue('http' in res)
netid = re.sub('^.*/', '', res)
netsum = self.wait_for_network_to_be_ready(client, netid)
self.assertIsNotNone(
netsum, 'Network is still not ready,'
' maybe server is busy?')
self.assertEqual(netid, netsum['externalId'])
self.assertTrue('name' in netsum, msg=str(netsum))
self.assertEqual(netname, netsum['name'], str(netsum))
self.assertEqual('PRIVATE', netsum['visibility'])
self.assertEqual(False, netsum['isReadOnly'])
self.assertEqual(1, netsum['edgeCount'])
self.assertEqual(2, netsum['nodeCount'])
self.assertEqual(False, netsum['isShowcase'])
self.assertEqual('NONE', netsum['indexLevel'])
newnet = NiceCXNetwork()
newres = newnet.update_to(netid,
creds['server'],
creds['user'],
creds['password'],
user_agent=creds['user_agent'])
self.assertEqual('', newres)
netsum = self.wait_for_network_to_be_ready(client,
netid,
num_retries=5,
retry_weight=1)
self.assertIsNotNone(
netsum, 'Network is still not ready,'
' maybe server is busy?')
self.assertEqual(netid, netsum['externalId'])
self.assertEqual('PRIVATE', netsum['visibility'])
self.assertEqual(False, netsum['isReadOnly'])
self.assertEqual(0, netsum['edgeCount'])
self.assertEqual(0, netsum['nodeCount'])
self.assertEqual(False, netsum['isShowcase'])
self.assertEqual('NONE', netsum['indexLevel'])
finally:
client.delete_network(netid)
try:
client.get_network_as_cx_stream(netid)
self.fail('Expected exception')
except HTTPError:
pass
def test_update_to_success(self):
with requests_mock.mock() as m:
resurl = client.DEFAULT_SERVER + '/v2/network/asdf'
m.get(self.get_rest_admin_status_url(),
json=self.get_rest_admin_status_dict("2.4.0"))
m.put(client.DEFAULT_SERVER + '/v2/network/abcd',
request_headers={'Connection': 'close'},
status_code=1,
text=resurl)
net = NiceCXNetwork()
net.create_node('bob')
res = net.update_to('abcd', client.DEFAULT_SERVER,
'bob', 'warnerbrandis',
user_agent='jeez')
self.assertEqual(res, resurl)
decode_txt = m.last_request.text.read().decode('UTF-8')
self.assertEqual(m.last_request.headers['User-Agent'],
client.userAgent + ' jeez')
self.assertTrue('Content-Disposition: form-data; name='
'"CXNetworkStream"; filename='
'"filename"' in decode_txt)
self.assertTrue('Content-Type: application/'
'octet-stream' in decode_txt)
self.assertTrue('{"nodes": [{' in decode_txt)
self.assertTrue('"@id": 0' in decode_txt)
self.assertTrue('"n": "bob"' in decode_txt)
self.assertTrue('"r": "bob"' in decode_txt)
self.assertTrue('{"status": [{"' in decode_txt)
self.assertTrue('"error": ""' in decode_txt)
self.assertTrue('"success": true' in decode_txt)
def test_get_network_attribute_names(self):
net = NiceCXNetwork()
# try on empty network
res = list(net.get_network_attribute_names())
self.assertEqual(0, len(res))
# try with one network attribute
net.add_network_attribute('foo')
res = list(net.get_network_attribute_names())
self.assertEqual(1, len(res))
self.assertTrue('foo' in res)
# try with two network attribute
net.add_network_attribute('bah', values='some value')
res = list(net.get_network_attribute_names())
self.assertEqual(2, len(res))
self.assertTrue('foo' in res)
self.assertTrue('bah' in res)
# try with 52 network attributes
for x in range(50):
net.add_network_attribute('attr' + str(x),
values='some value ' + str(x))
res = list(net.get_network_attribute_names())
self.assertEqual(52, len(res))
self.assertTrue('foo' in res)
self.assertTrue('bah' in res)
for x in range(50):
self.assertTrue('attr' + str(x) in res)
def test_add_opaque_aspect_invalid_type(self):
net_cx = NiceCXNetwork()
try:
net_cx.add_opaque_aspect('foo', 'invalid data')
self.fail('Expected Exception')
except Exception as e:
self.assertEqual('Provided input was not of type list.', str(e))
def test_set_network_attributes_from_style_network_complete_net(self):
net = NiceCXNetwork()
net.set_name(ndexloadncipid.COMPLETE_INTERACTION_NAME)
templatenet = NiceCXNetwork()
templatenet.set_name('well')
templatenet.set_network_attribute('description', values='hi', type='string')
templatenet.set_network_attribute('organism', values='some', type='string')
loader = NDExNciPidLoader(None)
loader._template = templatenet
res = loader._set_network_attributes_from_style_network(net)
self.assertEqual(0, len(res))
self.assertTrue('This network' in net.get_network_attribute('description')['v'])
self.assertEqual('some', net.get_network_attribute('organism')['v'])
def test_add_node_types_in_network_to_report_empty_network(self):
loader = NDExNciPidLoader(None)
report = NetworkIssueReport('foo')
net = NiceCXNetwork()
net.set_name('foo')
loader._add_node_types_in_network_to_report(net, report)
self.assertEqual(set(), report.get_nodetypes())
def test_create_edge_with_int_for_edge_ids(self):
net = NiceCXNetwork()
net.create_edge(edge_source=0, edge_target=1)
res = net.get_edge(0)
self.assertEqual(0, res[constants.EDGE_ID])
self.assertEqual(0, res[constants.EDGE_SOURCE])
self.assertEqual(1, res[constants.EDGE_TARGET])
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_empty_network_passed_in_with_various_legacy_modes(self):
net = NiceCXNetwork()
fac = DefaultNetworkXFactory()
g = fac.get_graph(net)
self.assertTrue(isinstance(g, networkx.MultiGraph))
self.assertEqual(0, len(g))
self.assertEqual(0, g.number_of_edges())
fac = DefaultNetworkXFactory(legacymode=True)
g = fac.get_graph(net)
self.assertTrue(isinstance(g, networkx.Graph))
self.assertEqual(0, len(g))
self.assertEqual(0, g.number_of_edges())
fac = DefaultNetworkXFactory(legacymode=False)
g = fac.get_graph(net)
self.assertTrue(isinstance(g, networkx.MultiGraph))
self.assertEqual(0, len(g))
self.assertEqual(0, g.number_of_edges())
fac = DefaultNetworkXFactory(legacymode=None)
g = fac.get_graph(net)
self.assertTrue(isinstance(g, networkx.MultiGraph))
self.assertEqual(0, len(g))
self.assertEqual(0, g.number_of_edges())
try:
DefaultNetworkXFactory(legacymode='blah')
self.fail('Expected NDExError')
except NDExError as ne:
self.assertEqual('blah not a valid value for '
'legacymode parameter', str(ne))
def test_two_node_one_edge_network(self):
net = NiceCXNetwork()
net.create_node('first')
net.create_node('second')
net.create_edge(edge_source=0, edge_target=1)
net.set_name('bob')
fac = DefaultNetworkXFactory()
g = fac.get_graph(net)
self.assertEqual('bob', g.graph['name'])
self.assertEqual(2, len(g))
self.assertEqual(1, g.number_of_edges())
self.assertTrue(0 in g)
if NETWORKX_MAJOR_VERSION >= 2:
nodelist = list(g.nodes(data=True))
edgelist = list(g.edges(data=True))
else:
nodelist = g.nodes(data=True)
edgelist = g.edges(data=True)
self.assertEqual('first', nodelist[0][1]['name'])
self.assertEqual('second', nodelist[1][1]['name'])
self.assertEqual(0, edgelist[0][0])
self.assertEqual(1, edgelist[0][1])
self.assertEqual(None, edgelist[0][2]['interaction'])
def test_add_pathway_info(self):
fargs = FakeArgs()
fargs.conf = 'hi'
fargs.iconurl = 'http://myicon'
fargs.edgecollapse = False
fargs.profile = 'profile'
fargs.datadir = '/foo'
fargs.visibility = 'PUBLIC'
loader = LoadSignorIntoNDEx(fargs, None)
net = NiceCXNetwork()
loader._add_pathway_info(net, 'Human', True, 'mypathway')
net_attr = net.get_network_attribute('description')
self.assertEqual(
'This network contains all the Human' +
' interactions currently available ' + 'in SIGNOR', net_attr['v'])
net_attr = net.get_network_attribute('organism')
self.assertEqual('H**o sapiens (human)', net_attr['v'])
net_attr = net.get_network_attribute('rightsHolder')
self.assertEqual('Prof. Gianni Cesareni', net_attr['v'])
net_attr = net.get_network_attribute('reference')
self.assertTrue('<a href="https://doi.org/10.1093/nar/gkv1048" '
'target="_blank">doi: 10.1093'
'/nar/gkv1048</a>' in net_attr['v'])
def test_set_type(self):
fargs = FakeArgs()
fargs.conf = 'hi'
fargs.profile = 'profile'
fargs.datadir = '/foo'
fargs.visibility = 'PUBLIC'
loader = LoadSignorIntoNDEx(fargs, None)
net = NiceCXNetwork()
# test default
net.set_name('foo')
loader._set_type(net)
res = net.get_network_attribute('networkType')
self.assertEqual(['pathway', 'Signalling Pathway'], res['v'])
# test disease pathway
net.set_name('fsgs')
loader._set_type(net)
res = net.get_network_attribute('networkType')
self.assertEqual(['pathway', 'Disease Pathway'], res['v'])
# test cancer pathway
net.set_name('prostate cancer')
loader._set_type(net)
res = net.get_network_attribute('networkType')
self.assertEqual(['pathway', 'Cancer Pathway'], res['v'])
#test interactome True
net.set_name('some name')
loader._set_type(net, is_human_fullpathway=True)
res = net.get_network_attribute('networkType')
self.assertEqual(['interactome', 'pathway', 'Signalling Pathway'],
res['v'])
def test_empty_network_passed_in_with_various_legacy_modes(self):
net = NiceCXNetwork()
fac = LegacyNetworkXVersionTwoPlusFactory()
g = fac.get_graph(net)
self.assertTrue(isinstance(g, networkx.Graph))
self.assertEqual(0, len(g))
self.assertEqual(0, g.number_of_edges())
def test_set_visual_properties_aspect_with_none(self):
mynet = NiceCXNetwork()
try:
mynet._set_visual_properties_aspect(None)
self.fail('Expected TypeError')
except TypeError as e:
self.assertEqual('Visual Properties aspect is None', str(e))
def get_nice_cx_network_from_clusterfile(inputfile):
"""
:param inputfile:
:return:
"""
network = NiceCXNetwork()
network.set_name('clustertocx from ' + str(os.path.basename(os.path.dirname(inputfile))))
with open(inputfile, 'r') as f:
data = f.read()
node_map = {}
protein_map = {}
for line in data.split(';'):
slist = line.split(',')
if len(slist) != 3:
sys.stderr.write(line + ' does not have appropriate number of columns. skipping\n')
continue
if slist[2].startswith('c-c'):
target_is_protein = False
else:
target_is_protein = True
if slist[0] not in node_map:
source_node_id = network.create_node(slist[0])
node_map[slist[0]] = source_node_id
network.add_node_attribute(property_of=source_node_id, name='suid', values=int(slist[0]), type='long')
network.add_node_attribute(property_of=source_node_id, name='type', values='term', type='string')
else:
source_node_id = node_map[slist[0]]
if target_is_protein:
if slist[0] not in protein_map:
protein_map[slist[0]] = set()
protein_map[slist[0]].add(slist[1])
else:
if slist[1] not in protein_map[slist[0]]:
protein_map[slist[0]].add(slist[1])
else:
target_node_id = network.create_node(slist[1])
network.create_edge(source_node_id, target_node_id, 'Child-Parent')
network.add_node_attribute(property_of=target_node_id, name='suid', values=int(slist[1]), type='long')
network.add_node_attribute(property_of=target_node_id, name='type', values='term', type='string')
node_map[slist[1]] = target_node_id
for nodename in protein_map:
genelist = protein_map[nodename]
if len(genelist) > 0:
genesymbol_list = []
for entry in genelist:
genesymbol_list.append(entry)
network.add_node_attribute(property_of=node_map[nodename], name='member', values=genesymbol_list,
type='list_of_string')
network.add_node_attribute(property_of=node_map[nodename], name='type', values='complex', type='string',
overwrite=True)
del node_map
del protein_map
return network
def test_to_networkx_invalid_mode_on_empty_network(self):
net = NiceCXNetwork()
try:
net.to_networkx(mode='someinvalidmode')
self.fail('Expected NDExError')
except NDExError as ne:
self.assertEqual('someinvalidmode is not a valid mode', str(ne))
def test_add_edge_to_network_using_src_target_node_ids(self):
net = NiceCXNetwork()
src_node = net.create_node('node1')
target_node = net.create_node('node2')
ne = NetworkEdge(edge_id=1,
source_node_id=src_node,
target_node_id=target_node,
interaction='activates')
self.assertEqual(0, len(net.get_edges()))
edge_id = ne.add_edge_to_network(net_cx=net)
self.assertEqual(1, len(net.get_edges()))
nef = NetworkEdgeFactory()
new_ne = nef.get_network_edge_from_network(net_cx=net, edge_id=edge_id)
self.assertEqual('node1', new_ne.get_source_node_name())
self.assertEqual('node2', new_ne.get_target_node_name())
self.assertEqual(src_node, new_ne.get_source_node_id())
self.assertEqual(target_node, new_ne.get_target_node_id())
self.assertEqual('activates', new_ne.get_interaction())
self.assertEqual([], new_ne.get_attributes())
new_ne.remove_edge_from_network(net_cx=net)
self.assertEqual(0, len(net.get_edges()))
def test_simple_create(self):
niceCx_creatures = NiceCXNetwork()
niceCx_creatures.set_name("Food Web")
fox_node = niceCx_creatures.create_node(node_name='Fox')
mouse_node = niceCx_creatures.create_node(node_name='Mouse')
bird_node = niceCx_creatures.create_node(node_name='Bird')
fox_bird_edge = niceCx_creatures.create_edge(
edge_source=fox_node,
edge_target=bird_node,
edge_interaction='interacts-with')
fox_mouse_edge = niceCx_creatures.create_edge(
edge_source=fox_node,
edge_target=mouse_node,
edge_interaction='interacts-with')
niceCx_creatures.add_node_attribute(property_of=fox_node,
name='Color',
values='Red')
niceCx_creatures.add_node_attribute(property_of=mouse_node,
name='Color',
values='Gray')
niceCx_creatures.add_node_attribute(property_of=bird_node,
name='Color',
values='Blue')
niceCx_creatures.add_edge_attribute(property_of=fox_mouse_edge,
name='Hunted',
values='On the ground')
print(niceCx_creatures.get_node_attribute(fox_node, 'Color'))
def test_basic_network(self):
net = NiceCXNetwork()
adjud = RedundantEdgeAdjudicator()
nid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='neighbor-of')
cid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='controls-state-change-of')
net.set_edge_attribute(cid,
RedundantEdgeAdjudicator.CITATION,
['pubmed:123'],
type='list_of_string')
oid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='someother')
net.set_edge_attribute(oid,
RedundantEdgeAdjudicator.CITATION,
['pubmed:123'],
type='list_of_string')
self.assertEqual('neighbor-of', net.get_edge(nid)['i'])
self.assertEqual('controls-state-change-of', net.get_edge(cid)['i'])
self.assertEqual('someother', net.get_edge(oid)['i'])
self.assertEqual([], adjud.update(net))
self.assertEqual(None, net.get_edge(nid))
self.assertEqual(None, net.get_edge(cid))
self.assertEqual('someother', net.get_edge(oid)['i'])
def test_set_network_attributes_from_style_network_description_set_org_not(self):
net = NiceCXNetwork()
net.set_name('foo')
templatenet = NiceCXNetwork()
templatenet.set_name('well')
templatenet.set_network_attribute('description', values='hi', type='string')
loader = NDExNciPidLoader(None)
loader._template = templatenet
res = loader._set_network_attributes_from_style_network(net)
self.assertEqual(1, len(res))
self.assertTrue('organism network' in res[0])
self.assertEqual('hi', net.get_network_attribute('description')['v'])
self.assertEqual(None, net.get_network_attribute('organism'))
def test_build_edge_map_single_edge_of_each_type(self):
adjud = RedundantEdgeAdjudicator()
net = NiceCXNetwork()
# try empty network
neighbor, controls, other = adjud._build_edge_map(net)
self.assertEqual({}, neighbor)
self.assertEqual({}, controls)
self.assertEqual({}, other)
# try network with single neighbor, controls, and an another edge
nid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='neighbor-of')
cid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='controls-state-change-of')
oid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='somethingelse')
neighbor, controls, other = adjud._build_edge_map(net)
self.assertEqual(nid, neighbor[0][1])
self.assertEqual(nid, neighbor[1][0])
self.assertEqual({cid}, controls[0][1])
self.assertEqual({oid}, other[0][1])
def test_remove_if_redundant_with_multiple_edges_same_citations(self):
net = NiceCXNetwork()
adjud = RedundantEdgeAdjudicator()
nid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='neighbor-of')
net.set_edge_attribute(nid,
RedundantEdgeAdjudicator.CITATION,
['pubmed:4', 'pubmed:123'],
type='list_of_string')
cid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='controls-state-change-of')
net.set_edge_attribute(cid,
RedundantEdgeAdjudicator.CITATION,
['pubmed:555', 'pubmed:4'],
type='list_of_string')
cidtwo = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='controls-state-change-of')
net.set_edge_attribute(cidtwo,
RedundantEdgeAdjudicator.CITATION,
['pubmed:4', 'pubmed:123'],
type='list_of_string')
self.assertEqual('neighbor-of', net.get_edge(nid)['i'])
adjud._remove_if_redundant(net, nid, [cid, cidtwo])
self.assertEqual(None, net.get_edge(nid))
def test_write_nice_cx_to_file(self):
temp_dir = tempfile.mkdtemp()
try:
p = MagicMock()
p.datadir = temp_dir
p.profile = 'foo'
p.organismloadplan = ndexloadbiogrid.get_organism_load_plan()
p.chemicalloadplan = ndexloadbiogrid.get_chemical_load_plan()
p.organismstyle = ndexloadbiogrid.get_organism_style()
p.chemstyle = ndexloadbiogrid.get_chemical_style()
p.biogridversion = '1.0.0'
p.skipdownload = False
loader = NdexBioGRIDLoader(p)
loader._network = NiceCXNetwork()
loader._network.create_node('hi')
loader._network.set_name('name')
cxfile = os.path.join(temp_dir, 'some.cx')
loader._write_nice_cx_to_file(cxfile)
self.assertTrue(os.path.isfile(cxfile))
checknet = ndex2.create_nice_cx_from_file(cxfile)
self.assertEqual('name', checknet.get_name())
finally:
shutil.rmtree(temp_dir)
def test_basic_network_where_neighbor_of_citations_merges_disabled(self):
net = NiceCXNetwork()
adjud = RedundantEdgeAdjudicator(disablcitededgemerge=True)
nid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='neighbor-of')
net.set_edge_attribute(nid,
RedundantEdgeAdjudicator.CITATION, ['pubmed:5'],
type='list_of_string')
cid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='controls-state-change-of')
oid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='someother')
self.assertEqual('neighbor-of', net.get_edge(nid)['i'])
self.assertEqual('controls-state-change-of', net.get_edge(cid)['i'])
self.assertEqual('someother', net.get_edge(oid)['i'])
self.assertEqual([], adjud.update(net))
self.assertEqual('neighbor-of', net.get_edge(nid)['i'])
self.assertEqual(None, net.get_edge(cid))
self.assertEqual('someother', net.get_edge(oid)['i'])
res = net.get_edge_attribute(nid, RedundantEdgeAdjudicator.CITATION)
res['v'].sort()
self.assertEqual(['pubmed:5'], res['v'])
res = net.get_edge_attribute(oid, RedundantEdgeAdjudicator.CITATION)
self.assertEqual((None, None), res)
def test_set_node_attribute_add_duplicate_attributes(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.set_node_attribute(1, 'attrname', 'value2')
res = net.get_node_attributes(1)
self.assertEqual(len(res), 2)
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')
self.assertEqual(res[1][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[1][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[1][constants.NODE_ATTR_VALUE], 'value2')
net.set_node_attribute(1, 'attrname', 'value3')
res = net.get_node_attributes(1)
self.assertEqual(len(res), 3)
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')
self.assertEqual(res[1][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[1][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[1][constants.NODE_ATTR_VALUE], 'value2')
self.assertEqual(res[2][constants.NODE_ATTR_PROPERTYOF], 1)
self.assertEqual(res[2][constants.NODE_ATTR_NAME], 'attrname')
self.assertEqual(res[2][constants.NODE_ATTR_VALUE], 'value3')
def test_build_edge_map_multiple_edges_of_each_type(self):
# try network with multiple neighbor, controls, and an another edge
net = NiceCXNetwork()
adjud = RedundantEdgeAdjudicator()
nid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='neighbor-of')
nidtwo = net.create_edge(edge_source=2,
edge_target=3,
edge_interaction='neighbor-of')
cid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='controls-state-change-of')
cidtwo = net.create_edge(edge_source=3,
edge_target=4,
edge_interaction='controls-state-change-of')
oid = net.create_edge(edge_source=0,
edge_target=1,
edge_interaction='somethingelse')
oidtwo = net.create_edge(edge_source=5,
edge_target=6,
edge_interaction='anotherthingy')
neighbor, controls, other = adjud._build_edge_map(net)
self.assertEqual(nid, neighbor[0][1])
self.assertEqual(nid, neighbor[1][0])
self.assertEqual(nidtwo, neighbor[2][3])
self.assertEqual(nidtwo, neighbor[3][2])
self.assertEqual({cid}, controls[0][1])
self.assertEqual({cidtwo}, controls[3][4])
self.assertEqual({oid}, other[0][1])
self.assertEqual({oidtwo}, other[5][6])
def test_add_node(self):
net_cx = NiceCXNetwork()
try:
net_cx.add_node()
self.fail('Expected Warning')
except Warning as we:
self.assertTrue('add_node() is deprecated' in str(we))
