def test_align():
a = Stream()
b = Stream()
z = a.AlignEventStreams(b)
sl = z.sink_to_list()
# TODO: use real run engine here
for n, d, dd in zip(
["start", "descriptor", "event", "stop"],
[
{"a": "hi", "b": {"hi": "world"}, "uid": "hi", "time": 123},
{"bla": "foo", "uid": "abc"},
{"data": "now", "descriptor": "abc"},
{"stop": "doc"},
],
[
{"a": "hi2", "b": {"hi2": "world"}},
{"bla": "foo", "uid": "123"},
{"data": "now", "descriptor": "123"},
{"stop": "doc"},
],
):
a.emit((n, d))
b.emit((n, dd))
assert len(sl) == 4
assert sl[0][1].get("b") == {"hi": "world", "hi2": "world"}
def test_align_interrupted(RE, hw):
a = Stream()
b = FromEventStream("event", ("data", "img"), a, principle=True).map(
op.add, 1
)
b.sink(print)
c = ToEventStream(b, ("out",))
z = move_to_first(a.AlignEventStreams(c))
sl = z.sink_to_list()
L = []
RE.subscribe(lambda *x: L.append(x))
RE(count([hw.img]))
for nd in L:
name, doc = nd
# cause an exception
if name == "event":
doc["data"]["img"] = "hi"
try:
a.emit((name, doc))
except TypeError:
pass
assert {"start", "stop"} == set(list(zip(*sl))[0])
# check that buffers are not cleared, yet
sl.clear()
# If there are elements in the buffer they need to be cleared when all
# start docs come in.
for nd in L:
name, doc = nd
# cause an exception
if name == "event":
doc["data"]["img"] = 1
a.emit((name, doc))
if name == "start":
# now buffers should be clear
assert not any(
[b for n, tb in z.true_buffers.items() for u, b in tb.items()]
)
assert {"start", "descriptor", "event", "stop"} == set(list(zip(*sl))[0])
# now buffers should be clear (as all docs were emitted)
assert not any(
[b for n, tb in z.true_buffers.items() for u, b in tb.items()]
)
def test_align_res_dat(RE, hw):
a = Stream()
b = FromEventStream("event", ("data", "motor"), a,
principle=True).map(op.add, 1)
c = ToEventStream(b, ("out", ))
z = a.AlignEventStreams(c)
sl = z.sink_to_list()
RE.subscribe(lambda *x: a.emit(x))
osu = RE(scan([hw.img], hw.motor, 0, 10, 10))
for n, d in sl:
if n == "start":
assert d["original_start_uid"] == osu[0]
if n == "event":
assert d["data"]["out"] == d["data"]["motor"] + 1
def test_align_buffering(RE, hw):
zz = {"data": False}
a = Stream()
b = FromEventStream(
"event",
("data", "motor"),
a.filter(lambda x: zz["data"]),
principle=True,
).map(op.add, 1)
c = ToEventStream(b, ("out",))
z = move_to_first(a.AlignEventStreams(c))
sl = z.sink_to_list()
RE.subscribe(lambda *x: a.emit(x))
RE(scan([hw.img], hw.motor, 0, 10, 10, md={"hello": "world"}))
zz["data"] = True
sl.clear()
RE(scan([hw.img], hw.motor, 0, 10, 10))
assert "hello" not in sl[0][1]
def test_align_multi_stream(RE, hw):
a = Stream()
b = FromEventStream(
"event",
("data", "motor"),
a,
principle=True,
event_stream_name="primary",
).map(op.add, 1)
c = ToEventStream(b, ("out",))
c.sink(print)
z = a.AlignEventStreams(c, event_stream_name="primary")
sl = z.sink_to_list()
RE.subscribe(lambda *x: a.emit(x))
def one_1d_step(detectors, motor, step):
"""
Inner loop of a 1D step scan
This is the default function for ``per_step`` param in 1D plans.
"""
yield from checkpoint()
yield from abs_set(motor, step, wait=True)
yield from trigger_and_read(list(detectors) + [motor], name="dark")
return (yield from trigger_and_read(list(detectors) + [motor]))
osu = RE(scan([hw.img], hw.motor, 0, 10, 10, per_step=one_1d_step))
assert len(sl) == 10 + 3
for n, d in sl:
if n == "start":
assert d["original_start_uid"] == osu[0]
if n == "event":
print(d)
assert d["data"]["out"] == d["data"]["motor"] + 1
