def configure(self, p, i, o):
self.fail = p.fail
#You must transform instance versions of the class cell types in this
#function.
self.gen = self.gen() #custom overriding can occur here.
self.inc = self.inc()
self.printer = ecto_test.Printer()
def test_user_defined_strands(nlevels, SchedType, execfn, expect):
s1 = ecto.Strand()
s2 = s1
s3 = ecto.Strand()
print "s1.id ==", s1.id
print "s2.id ==", s2.id
print "s3.id ==", s3.id
assert s1.id == s2.id
assert s3.id != s2.id
assert s3.id != s1.id
plasm = ecto.Plasm()
# plasm.movie_out("strands_%03d.dot")
gen = ecto_test.Generate("GENERATE", step=1.0, start=1.0)
noncurr = ecto_test.DontCallMeFromTwoThreads("ALPHA", strand=s1)
plasm.connect(gen[:] >> noncurr[:])
for k in range(nlevels):
n = ecto_test.DontCallMeFromTwoThreads("BETA_%d" % k, strand=s2)
plasm.connect(noncurr[:] >> n[:])
noncurr = n
printer = ecto_test.Printer("PRINTER")
plasm.connect(noncurr[:] >> printer[:])
sched = SchedType(plasm)
print "sched=", sched
execfn(sched)
result = noncurr.outputs.out
print "result=", result, "expect=", expect
assert (result == expect)
def make(Schedtype):
print 'Using :', Schedtype
plasm = ecto.Plasm()
gen = ecto_test.Generate("Gen", step=1.0, start=0.0)
printer = ecto_test.Printer("Printy")
ecto.log_to_file(fname)
plasm.connect(gen[:] >> printer[:])
return Schedtype(plasm)
def test_parameter_callbacks():
generate = ecto_test.Generate()
param_watcher = ecto_test.ParameterWatcher(value=2)
sleep = ecto_test.Sleep()
printer = ecto_test.Printer()
plasm = ecto.Plasm()
plasm.connect(generate["out"] >> param_watcher["input"],
param_watcher['output'] >> printer[:])
plasm.insert(sleep)
return dynamic_reconfigure_execute(plasm)
def test_dealer(Scheduler):
print "*" *80
print __name__, Scheduler
plasm = ecto.Plasm()
printer = ecto_test.Printer()
cards = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
dealer = ecto.Dealer(tendril=printer.inputs.at('in'), iterable=cards)
plasm.connect(dealer['out'] >> printer['in'])
sched = Scheduler(plasm)
sched.execute()
assert dealer.outputs.at('out').type_name == 'double'
assert dealer.outputs.out == 10
def test_fileI(Scheduler, file_like_object, realfile=False):
global cards
plasm = ecto.Plasm()
if not realfile:
file_like_object.writelines(filetext)
file_like_object.seek(0)
reader = ecto_test.FileI(file=ecto.istream(file_like_object))
printer = ecto_test.Printer()
plasm.connect(reader[:] >> printer[:])
sched = Scheduler(plasm)
sched.execute()
assert reader.outputs.output == cards[-1]
def test_async_stop_on_destructor():
generate = ecto_test.Generate()
param_watcher = ecto_test.ParameterWatcher(value=2)
sleep = ecto_test.Sleep()
printer = ecto_test.Printer()
plasm = ecto.Plasm()
plasm.connect(generate["out"] >> param_watcher["input"],
param_watcher['output'] >> printer[:])
plasm.insert(sleep)
#ecto.view_plasm(plasm)
sched = ecto.schedulers.Singlethreaded(plasm)
sched.execute_async()
time.sleep(3.0)
def test_serialization():
plasm = ecto.Plasm()
gen = ecto_test.Generate("Gen", step=1.0, start=0.0)
inc = ecto_test.Increment("Increment 0", delay=2)
plasm.connect(gen, "out", inc, "in")
for j in range(5): # one has already been added
inc_next = ecto_test.Increment("Increment_%u" % (j+1), delay=2)
plasm.connect(inc, "out", inc_next, "in")
inc = inc_next
printer = ecto_test.Printer("Printy")
plasm.connect(inc, "out", printer, "in")
plasm.save('python_graph.ecto')
plasm.execute(4);
def test_dealer_heterogenous_type_fail(Scheduler):
print "*" * 80
print __name__, Scheduler
printer = ecto_test.Printer()
cards = [1, 2, 3, 4, 5, 'hello', 7, 8, 9, 10]
dealer = ecto.Dealer(tendril=printer.inputs.at('in'), iterable=cards)
plasm = ecto.Plasm()
plasm.connect(dealer['out'] >> printer['in'])
sched = Scheduler(plasm)
try:
sched.execute()
assert False == " Should have thrown."
except ecto.FailedFromPythonConversion, e:
print "Threw as expected:", str(e)
assert 'cpp_typename double' in str(e)
def build_addergraph(nlevels):
plasm = ecto.Plasm()
#deprecating the movie_out stuff.
#plasm.movie_out("frames/ecto%04u.viz");
prevlevel = [
ecto_test.Add("Adder 0_%u" % x) for x in range(2**(nlevels - 1))
]
for adder in prevlevel:
gen0 = ecto_test.Generate("Generator", step=1.0, start=1.0)
gen1 = ecto_test.Generate("Generator", step=1.0, start=1.0)
conn1 = gen0["out"] >> adder["left"]
conn2 = gen1["out"] >> adder["right"]
print "conn1=", conn1
plasm.connect(conn1, conn2)
print "prev has", len(prevlevel)
for k in range(nlevels - 2, -1, -1):
print "****** k=", k, " ***********"
thislevel = [
ecto_test.Add("Adder %u_%u" % (k, x)) for x in range(2**k)
]
print "prevlevel=", prevlevel
print "thislevel=", thislevel
index = 0
print "for...", range(2**k)
for r in range(2**k):
print "prev[%u] => cur[%u]" % (index, r)
conn = prevlevel[index]["out"] >> thislevel[r]["left"]
print "conn=", conn
plasm.connect(conn)
index += 1
print "prev[%u] => cur[%u]" % (index, r)
conn2 = prevlevel[index]["out"] >> thislevel[r]["right"]
print "conn2=", conn2
plasm.connect(conn2)
index += 1
prevlevel = thislevel
assert len(prevlevel) == 1
final_adder = prevlevel[0]
printer = ecto_test.Printer("printy!")
#plasm.connect(final_adder, "out", printer, "in")
return (plasm, final_adder)
def test_parameter_callbacks():
generate = ecto_test.Generate()
param_watcher = ecto_test.ParameterWatcher(value=2)
sleep = ecto_test.Sleep()
printer = ecto_test.Printer()
plasm = ecto.Plasm()
plasm.connect(generate["out"] >> param_watcher["input"],
param_watcher['output'] >> printer[:])
plasm.insert(sleep)
#ecto.view_plasm(plasm)
sched = ecto.schedulers.Singlethreaded(plasm)
sched.execute_async()
while sched.running():
number = 1000
param_watcher.params.value = number
time.sleep(3.0)
sched.stop()
assert 1000 == param_watcher.outputs.value
def shouldfail():
plasm = ecto.Plasm()
gen = ecto_test.Generate(step=1.0, start=1.0)
nc1 = ecto_test.DontCallMeFromTwoThreads()
plasm.connect(gen, "out", nc1, "in")
nc2 = ecto_test.DontCallMeFromTwoThreads()
plasm.connect(nc1, "out", nc2, "in")
printer = ecto_test.Printer()
plasm.connect(nc2, "out", printer, "in")
sched = ecto.schedulers.Multithreaded(plasm)
try:
print "about to execute... this should throw"
sched.execute(nthreads=4, niter=4)
util.fail()
except RuntimeError, e:
print "good, python caught error", e
def test_constant():
print "test running.."
plasm = ecto.Plasm()
c = ecto.Constant(value=0.50505)
m = ecto_test.Multiply(factor=3.3335)
passthrough = ecto_test.PassthroughAny()
print passthrough.__doc__
print ">>>>DOC>>>>", c.__doc__
pr = ecto_test.Printer()
p = ecto.Plasm()
plasm.connect(c[:] >> m[:], m[:] >> passthrough[:],
passthrough[:] >> pr[:])
plasm.execute()
assert m.outputs.out == (0.50505 * 3.3335)
plasm.execute()
assert m.outputs.out == (0.50505 * 3.3335)
def test_implicit_strands(nlevels, SchedType, execfn, expect):
plasm = ecto.Plasm()
gen = ecto_test.Generate(step=1.0, start=1.0)
noncurr = ecto_test.CantCallMeFromTwoThreads()
plasm.connect(gen, "out", noncurr, "in")
for k in range(nlevels):
next = ecto_test.CantCallMeFromTwoThreads()
plasm.connect(noncurr, "out", next, "in")
noncurr = next
printer = ecto_test.Printer()
plasm.connect(noncurr, "out", printer, "in")
sched = SchedType(plasm)
print "sched=", sched
execfn(sched)
result = noncurr.outputs.out
print "result=", result
assert (result == expect)
def test_dual_line_plasm(nlevels):
plasm = ecto.Plasm()
gen = ecto_test.Generate(step=1.0, start=0.0)
incl, incr = ecto_test.Increment(), ecto_test.Increment()
plasm.connect(gen, "out", incl, "in")
plasm.connect(gen, "out", incr, "in")
for j in range(nlevels-1): # one set of incs has already been added
print j
inc_nextl, inc_nextr = ecto_test.Increment(), ecto_test.Increment()
plasm.connect(incl, "out", inc_nextl, "in")
plasm.connect(incr, "out", inc_nextr, "in")
incl, incr = inc_nextl, inc_nextr
add = ecto_test.Add()
plasm.connect(incl, "out", add, "left")
plasm.connect(incr, "out", add, "right")
printer = ecto_test.Printer()
plasm.connect(add, "out", printer, "in")
sched = ecto.schedulers.Threadpool(plasm)
sched.execute(niter=1, nthreads=int(nlevels/2))
result = add.outputs.out
print "result=", result
assert(result == nlevels * 2)
sched.execute(niter=2, nthreads=int(nlevels/2))
result = add.outputs.out
print "iter2 result=", result
assert result == (nlevels + 2) * 2
sched.execute(niter=3, nthreads=int(nlevels/2))
result = add.outputs.out
print "iter3 result=", result
assert result == (nlevels + 5) * 2
def test_plasm(Sched, nthreads, niter, n_nodes, incdelay):
plasm = ecto.Plasm()
gen = ecto_test.Generate("Gen", step=1.0, start=0.0)
inc = ecto_test.Increment("Increment 0", delay=incdelay)
plasm.connect(gen, "out", inc, "in")
for j in range(n_nodes-1): # one has already been added
inc_next = ecto_test.Increment("Increment_%u" % (j+1), delay=incdelay)
plasm.connect(inc, "out", inc_next, "in")
inc = inc_next
printer = ecto_test.Printer("Printy")
plasm.connect(inc, "out", printer, "in")
#
# o = open('graph.dot', 'w')
# print >>o, plasm.viz()
# o.close()
# print "\n", plasm.viz(), "\n"
sched = Sched(plasm)
sched.execute(niter, nthreads)
print "RESULT:", inc.outputs.out
shouldbe = float(n_nodes + niter - 1)
print "expected:", shouldbe
assert inc.outputs.out == shouldbe
#sched.execute(nthreads, niter)
#result = inc.outputs.out
#print "RESULT:", result
#shouldbe = float(n_nodes + (niter*2 - 1))
#assert result == shouldbe
return
#!/usr/bin/env python
import ecto, ecto_test, sys
plasm = ecto.Plasm()
gen = ecto_test.Generate("Gen", step=1.0, start=0.0)
inc = ecto_test.Increment("Increment 0", delay=100)
printer = ecto_test.Printer("Printy")
plasm.connect(gen[:] >> inc[:], inc[:] >> printer[:])
sched = ecto.schedulers.Threadpool(plasm)
ecto.log_to_file("ectolog.txt")
sched.execute_async(niter=100)
from IPython.Shell import IPShellEmbed
ipshell = IPShellEmbed()
ipshell()
def configure(self, p, i, o):
self.fail = p.fail
self.gen = self.gen() #custom overriding can occur here.
self.inc = self.inc()
self.printer = ecto_test.Printer()
#!/usr/bin/env python
import ecto
import ecto_test
plasm = ecto.Plasm()
printer = ecto_test.Printer()
cards = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
dealer = ecto.Dealer(tendril=printer.inputs.at('in'), iterable=cards)
plasm.connect(dealer['out'] >> printer['in'])
if __name__ == '__main__':
Scheduler = ecto.schedulers.Singlethreaded
sched = Scheduler(plasm)
sched.execute()
assert dealer.outputs.at('out').type_name == 'double'
assert dealer.outputs.out == 10
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
import ecto, ecto_test, sys, util
print ecto_test.RequiredIO.__doc__
#test
assert "out [double] REQUIRED" in ecto_test.RequiredIO.__doc__
assert "in [double] REQUIRED" in ecto_test.RequiredIO.__doc__
gen = ecto_test.Generate()
req = ecto_test.RequiredIO()
out = ecto_test.Printer(print_type="double")
try:
p = ecto.Plasm()
p.connect(gen[:] >> req[:])
print "checking..."
p.check()
util.fail()
except Exception, e:
print str(e)
assert "NotConnected" in str(e)
print e, '(threw as expected)'
try:
p = ecto.Plasm()
p.connect(req[:] >> out[:])
p = ecto.Plasm()
#test the old syntax.
p.connect(scatter, "out_0000", gather, "in_0000")
try:
p2 = ecto.Plasm()
p2.connect(scatter, "out_0000", gather, "idn_0001")
util.fail()
except ecto.NonExistant, e:
print ">>>",e
assert "'in_0000':type(int) 'in_0001':type(int) 'in_0002':type(int)" in str(e)
print "(threw as expected)\n\n"
try:
p2 = ecto.Plasm()
p2.connect(gather["out"] >> ecto_test.Printer(print_type="double")["in"])
util.fail("Should not work as there is a type mismatch...")
except ecto.TypeMismatch, e:
print "type:",type(e)
print ">>>",e
assert "from_typename int" in str(e)
assert "to_typename double" in str(e)
print "(threw as expected)"
try:
p2 = ecto.Plasm()
p2.connect(gather["out"],ecto_test.Printer(print_type="double")["in"])
util.fail("Should not work.")
except RuntimeError, e:
print e
assert 'Did you mean' in str(e)
