11546904243

Committed 18 Oct 2024 03:41PM UTC coverage: 96.804% (-0.04%) from 96.844%

Build # 11546904243

Build Type

push

github

Committed by

web-flow

Commit Message

add automatic break points based on magic method detection (#113)

* add automatic break points based on magic method detection

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix tests but undo magic methods

* fix tests

* support all magic methods

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* pre-commit fix

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Run Details

219 of 229 new or added lines in 5 files covered. (95.63%)

4 existing lines in 3 files now uncovered.

2635 of 2722 relevant lines covered (96.8%)

3.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.48

/tests/test_graph_group.py

import pytest

import znflow


class PlainNode(znflow.Node):
    def __init__(self, value):
        self.value = value

    def run(self):
        self.value += 1


def test_empty_grp_name():
    graph = znflow.DiGraph()

    with pytest.raises(ValueError):
        with graph.group():  # name required
            pass


def test_grp():
    graph = znflow.DiGraph()

    assert graph.active_group is None

    with graph.group("my_grp") as grp:
        assert graph.active_group == grp

        node = PlainNode(1)

    assert graph.active_group is None
    graph.run()

    assert grp.names == ("my_grp",)
    assert node.value == 2
    assert node.uuid in graph.nodes
    assert grp.names in graph.groups
    assert graph.get_group("my_grp").uuids == [node.uuid]

    assert len(graph.groups) == 1
    assert len(graph) == 1


def test_muliple_grps():
    graph = znflow.DiGraph()

    assert graph.active_group is None

    with graph.group("my_grp") as grp:
        assert graph.active_group == grp

        node = PlainNode(1)

    assert graph.active_group is None

    with graph.group("my_grp2") as grp2:
        assert graph.active_group == grp2

        node2 = PlainNode(2)

    assert graph.active_group is None

    graph.run()

    assert grp.names == ("my_grp",)
    assert grp2.names == ("my_grp2",)

    assert node.value == 2
    assert node2.value == 3

    assert node.uuid in graph.nodes
    assert node2.uuid in graph.nodes

    assert grp.names in graph.groups
    assert grp2.names in graph.groups

    assert graph.get_group(*grp.names).uuids == [node.uuid]
    assert graph.get_group(*grp2.names).uuids == [node2.uuid]

    assert len(graph.groups) == 2
    assert len(graph) == 2


def test_nested_grps():
    graph = znflow.DiGraph()

    with graph.group("my_grp") as grp:
        assert graph.active_group == grp
        with pytest.raises(TypeError):
            with graph.group("my_grp2"):
                pass


def test_grp_with_existing_nodes():
    with znflow.DiGraph() as graph:
        node = PlainNode(1)

        with graph.group("my_grp") as grp:
            assert graph.active_group == grp

            node2 = PlainNode(2)

    assert graph.active_group is None

    graph.run()

    assert grp.names == ("my_grp",)

    assert node.value == 2
    assert node2.value == 3

    assert node.uuid in graph.nodes
    assert node2.uuid in graph.nodes

    assert grp.names in graph.groups

    assert graph.get_group(*grp.names).uuids == [node2.uuid]

    assert len(graph.groups) == 1
    assert len(graph) == 2


def test_grp_with_multiple_nodes():
    with znflow.DiGraph() as graph:
        node = PlainNode(1)
        node2 = PlainNode(2)

        with graph.group("my_grp") as grp:
            assert graph.active_group == grp

            node3 = PlainNode(3)
            node4 = PlainNode(4)

    assert graph.active_group is None

    graph.run()

    assert grp.names == ("my_grp",)

    assert node.value == 2
    assert node2.value == 3
    assert node3.value == 4
    assert node4.value == 5

    assert node.uuid in graph.nodes
    assert node2.uuid in graph.nodes
    assert node3.uuid in graph.nodes
    assert node4.uuid in graph.nodes

    assert grp.names in graph.groups

    assert graph.get_group(*grp.names).uuids == [node3.uuid, node4.uuid]

    assert len(graph.groups) == 1
    assert len(graph) == 4


def test_reopen_grps():
    with znflow.DiGraph() as graph:
        with graph.group("my_grp") as grp:
            assert graph.active_group == grp

            node = PlainNode(1)

        with graph.group("my_grp") as grp2:
            assert graph.active_group == grp2

            node2 = PlainNode(2)

    assert graph.active_group is None

    graph.run()

    assert grp.names == ("my_grp",)
    assert grp.names == grp2.names

    assert node.value == 2
    assert node2.value == 3

    assert node.uuid in graph.nodes
    assert node2.uuid in graph.nodes

    assert grp.names in graph.groups

    assert graph.get_group(*grp.names).uuids == [node.uuid, node2.uuid]

    assert len(graph.groups) == 1
    assert len(graph) == 2


def test_tuple_grp_names():
    graph = znflow.DiGraph()

    assert graph.active_group is None
    with graph.group("grp", "1") as grp:
        assert graph.active_group == grp

        node = PlainNode(1)

    assert graph.active_group is None
    graph.run()

    assert grp.names == ("grp", "1")
    assert node.value == 2
    assert node.uuid in graph.nodes
    assert grp.names in graph.groups
    assert graph.get_group(*grp.names).uuids == [node.uuid]


def test_grp_nodify():
    @znflow.nodify
    def compute_mean(x, y):
        return (x + y) / 2

    graph = znflow.DiGraph()

    with graph.group("grp1"):
        n1 = compute_mean(2, 4)

    assert n1.uuid in graph.get_group("grp1").uuids


def test_grp_iter():
    graph = znflow.DiGraph()

    with graph.group("grp1") as grp:
        n1 = PlainNode(1)
        n2 = PlainNode(2)

    assert list(grp) == [n1.uuid, n2.uuid]


def test_grp_contains():
    graph = znflow.DiGraph()

    with graph.group("grp1") as grp:
        n1 = PlainNode(1)
        n2 = PlainNode(2)

    assert n1.uuid in grp
    assert n2.uuid in grp
    assert "foo" not in grp


def test_grp_len():
    graph = znflow.DiGraph()

    with graph.group("grp1") as grp:
        PlainNode(1)
        PlainNode(2)

    assert len(grp) == 2


def test_grp_getitem():
    graph = znflow.DiGraph()

    with graph.group("grp1") as grp:
        n1 = PlainNode(1)
        n2 = PlainNode(2)

    assert grp[n1.uuid] == n1
    assert grp[n2.uuid] == n2
    with pytest.raises(KeyError):
        grp["foo"]


def test_grp_nodes():
    graph = znflow.DiGraph()

    with graph.group("grp1") as grp:
        n1 = PlainNode(1)
        n2 = PlainNode(2)

    assert grp.nodes == [n1, n2]
    assert grp.uuids == [n1.uuid, n2.uuid]
    assert grp.names == ("grp1",)


def test_empty_grps():
    graph = znflow.DiGraph()

    with graph.group("grp1") as grp1:
        pass
    with graph.group("grp2") as grp2:
        pass

    assert len(grp1) == 0
    assert len(grp2) == 0
    assert grp1.uuids == []
    assert grp2.uuids == []

    assert grp1.names == ("grp1",)
    assert grp2.names == ("grp2",)

    assert len(graph.groups) == 2
    assert grp1.names in graph.groups
    assert grp2.names in graph.groups

1	import pytest	4✔
2
3	import znflow	4✔
4
5
6	class PlainNode(znflow.Node):	4✔
7	def __init__(self, value):	4✔
8	self.value = value	4✔
9
10	def run(self):	4✔
11	self.value += 1	4✔
12
13
14	def test_empty_grp_name():	4✔
15	graph = znflow.DiGraph()	4✔
16
17	with pytest.raises(ValueError):	4✔
18	with graph.group(): # name required	4✔
UNCOV 19	pass	1✔
20
21
22	def test_grp():	4✔
23	graph = znflow.DiGraph()	4✔
24
25	assert graph.active_group is None	4✔
26
27	with graph.group("my_grp") as grp:	4✔
28	assert graph.active_group == grp	4✔
29
30	node = PlainNode(1)	4✔
31
32	assert graph.active_group is None	4✔
33	graph.run()	4✔
34
35	assert grp.names == ("my_grp",)	4✔
36	assert node.value == 2	4✔
37	assert node.uuid in graph.nodes	4✔
38	assert grp.names in graph.groups	4✔
39	assert graph.get_group("my_grp").uuids == [node.uuid]	4✔
40
41	assert len(graph.groups) == 1	4✔
42	assert len(graph) == 1	4✔
43
44
45	def test_muliple_grps():	4✔
46	graph = znflow.DiGraph()	4✔
47
48	assert graph.active_group is None	4✔
49
50	with graph.group("my_grp") as grp:	4✔
51	assert graph.active_group == grp	4✔
52
53	node = PlainNode(1)	4✔
54
55	assert graph.active_group is None	4✔
56
57	with graph.group("my_grp2") as grp2:	4✔
58	assert graph.active_group == grp2	4✔
59
60	node2 = PlainNode(2)	4✔
61
62	assert graph.active_group is None	4✔
63
64	graph.run()	4✔
65
66	assert grp.names == ("my_grp",)	4✔
67	assert grp2.names == ("my_grp2",)	4✔
68
69	assert node.value == 2	4✔
70	assert node2.value == 3	4✔
71
72	assert node.uuid in graph.nodes	4✔
73	assert node2.uuid in graph.nodes	4✔
74
75	assert grp.names in graph.groups	4✔
76	assert grp2.names in graph.groups	4✔
77
78	assert graph.get_group(*grp.names).uuids == [node.uuid]	4✔
79	assert graph.get_group(*grp2.names).uuids == [node2.uuid]	4✔
80
81	assert len(graph.groups) == 2	4✔
82	assert len(graph) == 2	4✔
83
84
85	def test_nested_grps():	4✔
86	graph = znflow.DiGraph()	4✔
87
88	with graph.group("my_grp") as grp:	4✔
89	assert graph.active_group == grp	4✔
90	with pytest.raises(TypeError):	4✔
91	with graph.group("my_grp2"):	4✔
UNCOV 92	pass	1✔
93
94
95	def test_grp_with_existing_nodes():	4✔
96	with znflow.DiGraph() as graph:	4✔
97	node = PlainNode(1)	4✔
98
99	with graph.group("my_grp") as grp:	4✔
100	assert graph.active_group == grp	4✔
101
102	node2 = PlainNode(2)	4✔
103
104	assert graph.active_group is None	4✔
105
106	graph.run()	4✔
107
108	assert grp.names == ("my_grp",)	4✔
109
110	assert node.value == 2	4✔
111	assert node2.value == 3	4✔
112
113	assert node.uuid in graph.nodes	4✔
114	assert node2.uuid in graph.nodes	4✔
115
116	assert grp.names in graph.groups	4✔
117
118	assert graph.get_group(*grp.names).uuids == [node2.uuid]	4✔
119
120	assert len(graph.groups) == 1	4✔
121	assert len(graph) == 2	4✔
122
123
124	def test_grp_with_multiple_nodes():	4✔
125	with znflow.DiGraph() as graph:	4✔
126	node = PlainNode(1)	4✔
127	node2 = PlainNode(2)	4✔
128
129	with graph.group("my_grp") as grp:	4✔
130	assert graph.active_group == grp	4✔
131
132	node3 = PlainNode(3)	4✔
133	node4 = PlainNode(4)	4✔
134
135	assert graph.active_group is None	4✔
136
137	graph.run()	4✔
138
139	assert grp.names == ("my_grp",)	4✔
140
141	assert node.value == 2	4✔
142	assert node2.value == 3	4✔
143	assert node3.value == 4	4✔
144	assert node4.value == 5	4✔
145
146	assert node.uuid in graph.nodes	4✔
147	assert node2.uuid in graph.nodes	4✔
148	assert node3.uuid in graph.nodes	4✔
149	assert node4.uuid in graph.nodes	4✔
150
151	assert grp.names in graph.groups	4✔
152
153	assert graph.get_group(*grp.names).uuids == [node3.uuid, node4.uuid]	4✔
154
155	assert len(graph.groups) == 1	4✔
156	assert len(graph) == 4	4✔
157
158
159	def test_reopen_grps():	4✔
160	with znflow.DiGraph() as graph:	4✔
161	with graph.group("my_grp") as grp:	4✔
162	assert graph.active_group == grp	4✔
163
164	node = PlainNode(1)	4✔
165
166	with graph.group("my_grp") as grp2:	4✔
167	assert graph.active_group == grp2	4✔
168
169	node2 = PlainNode(2)	4✔
170
171	assert graph.active_group is None	4✔
172
173	graph.run()	4✔
174
175	assert grp.names == ("my_grp",)	4✔
176	assert grp.names == grp2.names	4✔
177
178	assert node.value == 2	4✔
179	assert node2.value == 3	4✔
180
181	assert node.uuid in graph.nodes	4✔
182	assert node2.uuid in graph.nodes	4✔
183
184	assert grp.names in graph.groups	4✔
185
186	assert graph.get_group(*grp.names).uuids == [node.uuid, node2.uuid]	4✔
187
188	assert len(graph.groups) == 1	4✔
189	assert len(graph) == 2	4✔
190
191
192	def test_tuple_grp_names():	4✔
193	graph = znflow.DiGraph()	4✔
194
195	assert graph.active_group is None	4✔
196	with graph.group("grp", "1") as grp:	4✔
197	assert graph.active_group == grp	4✔
198
199	node = PlainNode(1)	4✔
200
201	assert graph.active_group is None	4✔
202	graph.run()	4✔
203
204	assert grp.names == ("grp", "1")	4✔
205	assert node.value == 2	4✔
206	assert node.uuid in graph.nodes	4✔
207	assert grp.names in graph.groups	4✔
208	assert graph.get_group(*grp.names).uuids == [node.uuid]	4✔
209
210
211	def test_grp_nodify():	4✔
212	@znflow.nodify	4✔
213	def compute_mean(x, y):	4✔
214	return (x + y) / 2	×
215
216	graph = znflow.DiGraph()	4✔
217
218	with graph.group("grp1"):	4✔
219	n1 = compute_mean(2, 4)	4✔
220
221	assert n1.uuid in graph.get_group("grp1").uuids	4✔
222
223
224	def test_grp_iter():	4✔
225	graph = znflow.DiGraph()	4✔
226
227	with graph.group("grp1") as grp:	4✔
228	n1 = PlainNode(1)	4✔
229	n2 = PlainNode(2)	4✔
230
231	assert list(grp) == [n1.uuid, n2.uuid]	4✔
232
233
234	def test_grp_contains():	4✔
235	graph = znflow.DiGraph()	4✔
236
237	with graph.group("grp1") as grp:	4✔
238	n1 = PlainNode(1)	4✔
239	n2 = PlainNode(2)	4✔
240
241	assert n1.uuid in grp	4✔
242	assert n2.uuid in grp	4✔
243	assert "foo" not in grp	4✔
244
245
246	def test_grp_len():	4✔
247	graph = znflow.DiGraph()	4✔
248
249	with graph.group("grp1") as grp:	4✔
250	PlainNode(1)	4✔
251	PlainNode(2)	4✔
252
253	assert len(grp) == 2	4✔
254
255
256	def test_grp_getitem():	4✔
257	graph = znflow.DiGraph()	4✔
258
259	with graph.group("grp1") as grp:	4✔
260	n1 = PlainNode(1)	4✔
261	n2 = PlainNode(2)	4✔
262
263	assert grp[n1.uuid] == n1	4✔
264	assert grp[n2.uuid] == n2	4✔
265	with pytest.raises(KeyError):	4✔
266	grp["foo"]	4✔
267
268
269	def test_grp_nodes():	4✔
270	graph = znflow.DiGraph()	4✔
271
272	with graph.group("grp1") as grp:	4✔
273	n1 = PlainNode(1)	4✔
274	n2 = PlainNode(2)	4✔
275
276	assert grp.nodes == [n1, n2]	4✔
277	assert grp.uuids == [n1.uuid, n2.uuid]	4✔
278	assert grp.names == ("grp1",)	4✔
279
280
281	def test_empty_grps():	4✔
282	graph = znflow.DiGraph()	4✔
283
284	with graph.group("grp1") as grp1:	4✔
285	pass	4✔
286	with graph.group("grp2") as grp2:	4✔
287	pass	4✔
288
289	assert len(grp1) == 0	4✔
290	assert len(grp2) == 0	4✔
291	assert grp1.uuids == []	4✔
292	assert grp2.uuids == []	4✔
293
294	assert grp1.names == ("grp1",)	4✔
295	assert grp2.names == ("grp2",)	4✔
296
297	assert len(graph.groups) == 2	4✔
298	assert grp1.names in graph.groups	4✔
299	assert grp2.names in graph.groups	4✔

zincware / ZnFlow / 11546904243

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous