def test_get(self):
with pytest.raises(BluepySnapError):
self.test_obj.get(properties=["other2", "unknown"])
ids = CircuitEdgeIds.from_dict({"default": [0, 1, 2, 3], "default2": [0, 1, 2, 3]})
tested = self.test_obj.get(ids, None)
assert tested == ids
tested = self.test_obj.get(ids, properties=self.test_obj.property_names)
assert len(tested) == 8
assert len(list(tested)) == 24
# put NaN for the undefined values : only values for default2 in dropna
assert len(tested.dropna()) == 4
# the index of the dataframe is indentical to the CircuitEdgeIds index
pdt.assert_index_equal(tested.index, ids.index)
pdt.assert_frame_equal(
self.test_obj.get([0, 1, 2, 3], properties=self.test_obj.property_names), tested)
# tested columns
tested = self.test_obj.get(ids, properties=["other2", "other1", "@source_node"])
assert tested.shape == (self.test_obj.size, 3)
assert list(tested) == ["other2", "other1", "@source_node"]
tested = self.test_obj.get(CircuitEdgeIds.from_dict({"default2": [0, 1, 2, 3]}),
properties=["other2", "other1", "@source_node"])
assert tested.shape == (4, 3)
# correct ordering when setting the dataframe with the population dataframe
assert tested.loc[("default2", 0)].tolist() == [10, 'A', 2]
with pytest.raises(KeyError):
tested.loc[("default", 0)]
tested = self.test_obj.get(CircuitEdgeIds.from_dict({"default": [0, 1, 2, 3]}),
properties=["other2", "other1", '@source_node'])
assert tested.shape == (4, 3)
assert tested.loc[("default", 0)].tolist() == [np.NaN, np.NaN, 2]
assert tested.loc[("default", 1)].tolist() == [np.NaN, np.NaN, 0]
tested = self.test_obj.get(ids, properties='@source_node')
assert tested["@source_node"].tolist() == [2, 0, 0, 2, 2, 0, 0, 2]
tested = self.test_obj.get(ids, properties='other2')
assert tested["other2"].tolist() == [np.NaN, np.NaN, np.NaN, np.NaN, 10, 11, 12, 13]
with pytest.raises(BluepySnapError):
self.test_obj.get(ids, properties=["other2", "unknown"])
with pytest.raises(BluepySnapError):
self.test_obj.get(ids, properties="unknown")
with pytest.deprecated_call():
self.test_obj.get(ids)
def test_afferent_edges(self):
# without the properties
target = CircuitNodeIds.from_dict({"default": [0, 1]})
assert self.test_obj.afferent_edges(target, None) == CircuitEdgeIds.from_dict(
{"default": [0, 1, 2, 3], "default2": [0, 1, 2, 3]})
# with a single int
expected = CircuitEdgeIds.from_dict({"default": [1, 2, 3], "default2": [1, 2, 3]})
assert self.test_obj.afferent_edges(1, None) == expected
# with a CircuitNodeId
assert self.test_obj.afferent_edges(CircuitNodeId("default", 1), None) == expected
properties = [Synapse.AXONAL_DELAY]
pdt.assert_frame_equal(
self.test_obj.afferent_edges(1, properties),
pd.DataFrame(
[
[88.1862],
[52.1881],
[11.1058],
[88.1862],
[52.1881],
[11.1058],
],
columns=properties, index=expected.index
),
check_dtype=False
)
# with an undefined other1 field for the population default
properties = [Synapse.SOURCE_NODE_ID, "other1"]
expected_index = CircuitEdgeIds.from_dict({"default": [0, 1, 2, 3], "default2": [0, 1, 2, 3]})
pdt.assert_frame_equal(
self.test_obj.afferent_edges(CircuitNodeIds.from_dict({"default": [0, 1]}), properties=properties),
pd.DataFrame(
[
[2, np.nan],
[0, np.nan],
[0, np.nan],
[2, np.nan],
[2, "A"],
[0, "B"],
[0, "C"],
[2, "D"],
],
columns=properties, index=expected_index.index
),
check_dtype=False
)
def _add_edge_ids(its, source, target, pop_name):
"""Generator comprehension adding the CircuitIds to the iterator."""
return ((
CircuitNodeId(source, source_id),
CircuitNodeId(target, target_id),
CircuitEdgeIds.from_dict({pop_name: edge_id}),
) for source_id, target_id, edge_id in its)
def test_get_all_edge_ids_types(self):
assert self.test_obj.get(0, Synapse.PRE_GID).tolist() == [2]
assert self.test_obj.get([0], Synapse.PRE_GID).tolist() == [2]
assert self.test_obj.get([0, 1], Synapse.PRE_GID).tolist() == [2, 0]
assert self.test_obj.get(CircuitEdgeId("default", 0), Synapse.PRE_GID).tolist() == [
2]
assert self.test_obj.get(CircuitEdgeIds.from_tuples([("default", 0)]),
Synapse.PRE_GID).tolist() == [2]
assert self.test_obj.get(CircuitEdgeId("default2", 0),
Synapse.PRE_GID).tolist() == []
assert self.test_obj.get(
CircuitEdgeIds.from_tuples([("default", 0), ("default", 1)]),
Synapse.PRE_GID).tolist() == [2, 0]
assert self.test_obj.get(
CircuitEdgeIds.from_tuples([("default", 0), ("default2", 1)]),
Synapse.PRE_GID).tolist() == [2]
assert self.test_obj.get(
CircuitEdgeIds.from_tuples([("default2", 0), ("default2", 1)]),
Synapse.PRE_GID).tolist() == []
def test_efferent_edges(self):
target = CircuitNodeIds.from_dict({"default": [2]})
expected = CircuitEdgeIds.from_dict({"default": [0, 3], "default2": [0, 3]})
assert self.test_obj.efferent_edges(target, None) == expected
assert self.test_obj.efferent_edges(2, None) == expected
assert self.test_obj.efferent_edges(CircuitNodeId("default", 2), None) == expected
properties = [Synapse.AXONAL_DELAY]
pdt.assert_frame_equal(
self.test_obj.efferent_edges(2, properties),
pd.DataFrame(
[
[99.8945],
[11.1058],
[99.8945],
[11.1058],
],
columns=properties, index=expected.index
),
check_dtype=False
)
# with an undefined other1 field for the population default
properties = [Synapse.TARGET_NODE_ID, "other1"]
expected_index = CircuitEdgeIds.from_dict(
{"default": [0, 3], "default2": [0, 3]})
pdt.assert_frame_equal(
self.test_obj.efferent_edges(2, properties),
pd.DataFrame(
[
[0, np.nan],
[1, np.nan],
[0, "A"],
[1, "D"],
],
columns=properties, index=expected_index.index
),
check_dtype=False
)
def test_pair_edges(self):
# no connection between 0 and 2
assert self.test_obj.pair_edges(0, 2, None) == CircuitEdgeIds.from_arrays([], [])
actual = self.test_obj.pair_edges(0, 2, [Synapse.AXONAL_DELAY])
assert actual.empty
assert self.test_obj.pair_edges(2, 0, None) == CircuitEdgeIds.from_tuples([('default', 0),
('default2', 0)])
properties = [Synapse.AXONAL_DELAY]
pdt.assert_frame_equal(
self.test_obj.pair_edges(2, 0, properties),
pd.DataFrame(
[
[99.8945],
[99.8945],
],
columns=properties, index=CircuitEdgeIds.from_tuples([('default', 0), ('default2', 0)]).index
),
check_dtype=False
)
def test_ids(self):
tested = self.test_obj.ids()
npt.assert_equal(tested, np.array([0, 1, 2, 3]))
npt.assert_equal(tested.dtype, IDS_DTYPE)
assert self.test_obj.ids(0) == [0]
npt.assert_equal(self.test_obj.ids([0, 1]), np.array([0, 1]))
npt.assert_equal(self.test_obj.ids(np.array([0, 1])), np.array([0, 1]))
npt.assert_equal(self.test_obj.ids(CircuitEdgeId("default", 0)), [0])
npt.assert_equal(self.test_obj.ids(CircuitEdgeId("default2", 0)), [])
ids = CircuitEdgeIds.from_tuples([("default", 0), ("default", 1)])
npt.assert_equal(self.test_obj.ids(ids), np.array([0, 1]))
ids = CircuitEdgeIds.from_tuples([("default", 0), ("default2", 1)])
npt.assert_equal(self.test_obj.ids(ids), np.array([0]))
ids = CircuitEdgeIds.from_tuples([("default2", 0), ("default2", 1)])
npt.assert_equal(self.test_obj.ids(ids), [])
npt.assert_equal(self.test_obj.ids(), np.array([0, 1, 2, 3]))
# limit too big compared to the number of ids
npt.assert_equal(self.test_obj.ids(limit=15), [0, 1, 2, 3])
npt.assert_equal(len(self.test_obj.ids(sample=2)), 2)
# if sample > population.size --> sample = population.size
npt.assert_equal(len(self.test_obj.ids(sample=25)), 4)
def test_iter_connections(self):
ids = CircuitNodeIds.from_dict({"default": [0, 1, 2], "default2": [0, 1, 2]})
# ordered by target
expected = [
(CircuitNodeId('default', 2), CircuitNodeId('default', 0)),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 0)),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1))
]
for i, tested in enumerate(self.test_obj.iter_connections(source=ids, target=ids)):
assert tested == expected[i]
for i, tested in enumerate(self.test_obj.iter_connections(source=None, target=ids)):
assert tested == expected[i]
# same but ordered by source
expected = [
(CircuitNodeId('default', 0), CircuitNodeId('default', 1)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 0)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1)),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 0)),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1))
]
for i, tested in enumerate(self.test_obj.iter_connections(source=ids, target=None)):
assert tested == expected[i]
expected = [
(CircuitNodeId('default', 2), CircuitNodeId('default', 0), CircuitEdgeIds.from_dict({'default': [0]})),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1), CircuitEdgeIds.from_dict({'default': [1, 2]})),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1), CircuitEdgeIds.from_dict({'default': [3]})),
(CircuitNodeId('default', 2), CircuitNodeId('default', 0), CircuitEdgeIds.from_dict({'default2': [0]})),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1), CircuitEdgeIds.from_dict({'default2': [1, 2]})),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1), CircuitEdgeIds.from_dict({'default2': [3]}))
]
for i, tested in enumerate(self.test_obj.iter_connections(source=ids, target=ids,
return_edge_ids=True)):
assert tested == expected[i]
expected = [
(CircuitNodeId('default', 2), CircuitNodeId('default', 0), 1),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1), 2),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1), 1),
(CircuitNodeId('default', 2), CircuitNodeId('default', 0), 1),
(CircuitNodeId('default', 0), CircuitNodeId('default', 1), 2),
(CircuitNodeId('default', 2), CircuitNodeId('default', 1), 1),
]
for i, tested in enumerate(self.test_obj.iter_connections(source=ids, target=ids,
return_edge_count=True)):
assert tested == expected[i]
with pytest.raises(BluepySnapError):
next(self.test_obj.iter_connections(ids, ids, return_edge_ids=True,
return_edge_count=True))
def test_pathway_edges(self):
properties = [Synapse.AXONAL_DELAY]
source = CircuitNodeIds.from_dict({"default": [0, 1]})
target = CircuitNodeIds.from_dict({"default": [1, 2]})
expected_index = CircuitEdgeIds.from_dict({"default": [1, 2], "default2": [1, 2]})
pdt.assert_frame_equal(
self.test_obj.pathway_edges(source=source, target=target, properties=properties),
pd.DataFrame(
[
[88.1862],
[52.1881],
[88.1862],
[52.1881],
],
columns=properties, index=expected_index.index
),
check_dtype=False
)
properties = [Synapse.SOURCE_NODE_ID, "other1"]
expected_index = CircuitEdgeIds.from_dict({"default": [1, 2], "default2": [1, 2]})
pdt.assert_frame_equal(
self.test_obj.pathway_edges(source=source, target=target, properties=properties),
pd.DataFrame(
[
[0, np.nan],
[0, np.nan],
[0, "B"],
[0, "C"],
],
columns=properties, index=expected_index.index
),
check_dtype=False
)
# without the properties should return the CircuitEdgeIds
assert self.test_obj.pathway_edges(source, target) == expected_index
assert self.test_obj.pathway_edges(source, target, None) == expected_index
# without the properties and the target
assert self.test_obj.pathway_edges(source, None) == CircuitEdgeIds.from_dict(
{"default": [1, 2], "default2": [1, 2]})
# without the properties and the source
assert self.test_obj.pathway_edges(None, source) == CircuitEdgeIds.from_dict(
{"default": [0, 1, 2, 3], "default2": [0, 1, 2, 3]})
# raise if both source and target are not set
with pytest.raises(BluepySnapError):
self.test_obj.pathway_edges(None, None, None)
# test with simple CircuitNodeId
properties = [Synapse.SOURCE_NODE_ID, Synapse.TARGET_NODE_ID]
source = CircuitNodeId("default", 0)
target = CircuitNodeId("default", 1)
expected_index = CircuitEdgeIds.from_dict({"default": [1, 2], "default2": [1, 2]})
pdt.assert_frame_equal(
self.test_obj.pathway_edges(source=source, target=target, properties=properties),
pd.DataFrame(
[
[0, 1],
[0, 1],
[0, 1],
[0, 1],
],
columns=properties, index=expected_index.index
),
check_dtype=False
)
# use global mapping for nodes
assert self.test_obj.pathway_edges(source={"mtype": "L6_Y"}, target={"mtype": "L2_X"}) == CircuitEdgeIds.from_tuples([("default", 0), ("default2", 0)])
def test_properties(self):
ids = CircuitEdgeIds.from_dict({"default": [0, 1, 2, 3], "default2": [0, 1, 2, 3]})
pdt.assert_frame_equal(self.test_obj.properties(ids, properties=["other2", "@source_node"]),
self.test_obj.get(ids, properties=["other2", "@source_node"]),
check_exact=False)
def test_ids(self):
np.random.seed(42)
# single edge ID --> CircuitEdgeIds return populations with the 0 id
expected = CircuitEdgeIds.from_tuples([("default", 0), ("default2", 0)])
tested = self.test_obj.ids(0)
assert tested == expected
npt.assert_equal(tested.get_ids().dtype, IDS_DTYPE)
# single edge ID list --> CircuitEdgeIds return populations with the 0 id
expected = CircuitEdgeIds.from_tuples([("default", 0), ("default2", 0)])
assert self.test_obj.ids([0]) == expected
# default3 population does not exist and is asked explicitly
with pytest.raises(BluepySnapError):
ids = CircuitEdgeIds.from_arrays(["default", "default3"], [0, 3])
self.test_obj.ids(ids)
# seq of node ID --> CircuitEdgeIds return populations with the array of ids
expected = CircuitEdgeIds.from_arrays(["default", "default", "default2", "default2"],
[0, 1, 0, 1])
tested = self.test_obj.ids([0, 1])
assert tested == expected
tested = self.test_obj.ids((0, 1))
assert tested == expected
tested = self.test_obj.ids(np.array([0, 1]))
assert tested == expected
ids = [CircuitEdgeId("default", 0), CircuitEdgeId("default", 1)]
assert self.test_obj.ids(ids) == CircuitEdgeIds.from_dict({"default": [0, 1]})
with pytest.raises(BluepySnapError):
ids = [CircuitEdgeId("default", 0), ("default", 1)]
self.test_obj.ids(ids)
# Check operations on global ids
ids = self.test_obj.ids([0, 1, 2, 3])
assert ids.filter_population("default").append(ids.filter_population("default2")) == ids
expected = CircuitEdgeIds.from_arrays(["default2", "default2"], [0, 1])
assert ids.filter_population("default2").limit(2) == expected
tested = self.test_obj.ids(sample=2)
expected = CircuitEdgeIds.from_arrays(["default2", "default"], [2, 3], sort_index=False)
assert tested == expected
tested = self.test_obj.ids(limit=5)
expected = CircuitEdgeIds.from_dict({"default": [0, 1, 2, 3], "default2": [0]})
assert tested == expected
with pytest.raises(BluepySnapError) as e:
self.test_obj.ids({'afferent_center_i': (10, 11)})
assert "Unknown edge properties: {'afferent_center_i'}" == e.value.args[0]
tested = self.test_obj.ids({"afferent_center_x": (1110, 1110.5)})
expected = CircuitEdgeIds.from_dict({"default": [0], "default2": [0]})
assert tested == expected
tested = self.test_obj.ids({"afferent_center_x": (1111, 1112), "efferent_center_z": (2132, 2134)})
expected = CircuitEdgeIds.from_dict({"default": [2], "default2": [2]})
assert tested == expected
tested = self.test_obj.ids({'$and': [{"@dynamics:param1": (0, 2)}, {"afferent_surface_x": (1211, 1211)}]})
expected = CircuitEdgeIds.from_dict({"default": [1], "default2": [1]})
assert tested == expected
tested = self.test_obj.ids({'$or': [{"@dynamics:param1": (0, 2)}, {"@source_node": [0]}]})
expected = CircuitEdgeIds.from_dict({"default": [0, 1, 2], "default2": [0, 1, 2]})
assert tested == expected
tested = self.test_obj.ids({"population": ["default2"], "afferent_center_x": (1113, 1114)})
expected = CircuitEdgeIds.from_dict({"default2": [3]})
assert tested == expected
tested = self.test_obj.ids({"population": ["default3"], "afferent_center_x": (1113, 1114)})
expected = CircuitEdgeIds.from_arrays([], [])
assert tested == expected
tested = self.test_obj.ids({"population": ["default", "default2"], "@target_node": [1]})
expected = CircuitEdgeIds.from_dict({"default": [1, 2, 3], "default2": [1, 2, 3]})
assert tested == expected