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 execute_plasm(self, 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)
print("RESULT:", inc.outputs.out)
shouldbe = float(n_nodes + niter - 1)
print("expected:", shouldbe)
assert inc.outputs.out == shouldbe
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_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.Scheduler(plasm)
sched.execute_async()
for i in range(0, 10):
sched.run_job()
def test_dealer(Scheduler):
print "*" *80
print __name__, 'test_dealer', 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)
print 'executing ...'
sched.execute()
print 'finished executing'
assert dealer.outputs.at('out').type_name == 'double'
assert dealer.outputs.out == 10
def test_dealer_heterogenous_type_fail(Scheduler):
print "*" * 80
print __name__, 'test_dealer_heterogenous_type_fail', 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 re.findall('cpp_typename.*double', str(e))
def test_constant():
print "test running.."
c = ecto.Constant(value=0.50505)
m = ecto_test.Multiply(factor=3.3335)
print ">>>>DOC>>>>", c.__doc__
pr = ecto_test.Printer()
plasm = ecto.Plasm()
plasm.connect(c[:] >> m[:], m[:] >> pr[:])
plasm.execute()
assert m.outputs.out == (0.50505 * 3.3335)
plasm.execute()
assert m.outputs.out == (0.50505 * 3.3335)
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.Scheduler(plasm)
sched.execute_async(1)
sched.run_job() # check plasm, init parms, and compute_stack
number = 1000
param_watcher.params.value = number
sched.run()
assert 1000 == param_watcher.outputs.value
def test_0_save_plasm(self):
n_nodes = 5
incdelay = 1
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")
plasm.save(self.FILE)
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.Scheduler(plasm)
try:
print "about to execute... this should throw"
sched.execute(niter=4)
util.fail()
except RuntimeError, e:
print "good, python caught error", e
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.Scheduler(plasm)
sched.execute(niter=1)
result = add.outputs.out
print "result=", result
assert (result == nlevels * 2)
sched.execute(niter=2)
result = add.outputs.out
print "iter2 result=", result
assert result == (nlevels + 2) * 2
sched.execute(niter=3)
result = add.outputs.out
print "iter3 result=", result
assert result == (nlevels + 5) * 2
#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 re.findall("from_typename.*int", str(e))
assert re.findall("to_typename.*double", 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)
# 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, sys, util
import ecto.ecto_test as ecto_test
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[:])
def configure(self, p, i, o):
self.fail = p.at('fail').val
self.printer = ecto_test.Printer()
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# 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
import ecto.ecto_test as ecto_test
import sys, time
plasm = ecto.Plasm()
uni = ecto_test.Uniform01("Random", seed=17)
print "OUTPUTS:", uni.outputs
printer = ecto_test.Printer("Printy")
print ecto.version()
plasm.connect(uni["out"] >> (printer["in"]))
sched = ecto.Scheduler(plasm)
sched.execute(niter=100)
import ecto.ecto_test as ecto_test
import yaml
import argparse
parser = argparse.ArgumentParser(description='My awesome program thing.')
parser.add_argument('-i,--input',
metavar='IMAGE_FILE',
dest='imagefile',
type=str,
default='',
help='an image file to load.')
scheduler_options(parser, default_niter=2)
multiply_factory = cell_options(parser, ecto_test.Multiply, prefix='mult')
const_factory = cell_options(parser,
ecto.Constant(value=0.50505),
prefix='const')
#parser.print_help()
options = parser.parse_args()
c = const_factory(options)
m = multiply_factory(options)
cyaml = CellYamlFactory(c, 'const')
print cyaml.dump()
c = cyaml.load(yaml.load(cyaml.dump()))
pr = ecto_test.Printer()
plasm = ecto.Plasm()
plasm.connect(c[:] >> m[:], m[:] >> pr[:])
run_plasm(options, plasm, locals=vars())
def configure(self, p, i, o):
self.printer = ecto_test.Printer()
