def testgetTargets(self):
t1 = Target('t1')
t2 = Target('t2')
cmd = Command('tag', None, t1)
cmd2 = Command('tag', None, t2=t2)
cp = CommandPack([cmd, cmd2])
tset = set(cp.getTargets())
self.failUnlessEqual(tset, set([t1, t2]))
def test_get_target_cont(self):
foo_tgt = Target('foo')
bar_tgt = Target('bar')
spam_src = Source('spam')
c1 = Command('foo', None, foo_tgt, x=bar_tgt, src=spam_src)
tc = c1.target_containers
self.failUnlessEqual(len(tc), 2)
self.failUnless('foo' in tc)
self.failUnless('bar' in tc)
self.failIf('spam' in tc)
def setunusedtarget( self, target ):
"""
if this command contains an un-instanciated target class
then replace it with @parameter: Target
returns True if un-instanciated Source is found and false if not
"""
if not isinstance( target, Node ):
target = Target( target )
for i in range( len( self.params ) ):
if self.params[i] == Target:
self.params[i] = target
return
for k in self.kparams.keys():
if self.kparams[k] == Target:
self.kparams[k] = target
return
if Target in self._other_dependants:
self._other_dependants.remove( Target)
self._other_dependants.add( target )
return
raise Exception( 'No target to set' )
def setUp(self):
"""
create commands
"""
self.sourceOf1 = Source(1)
self.sourceOfBob = Source('bob')
self.targetOf2 = Target(2)
self.targetOfFoo = Target('foo')
self.c1 = Command('testFunc', '__adder', 1, a=2)
self.c2 = Command('testFunc', '__adder', 3, b=Source)
self.c3 = Command('testFunc', '__adder', self.sourceOf1,
self.sourceOfBob)
self.c4 = Command('testFunc', '__adder', self.targetOfFoo,
self.targetOf2)
# for cmd in [self.c1,self.c2,self.c3,self.c4]:
self.c1.func = testFunc
def testgetTargets(self):
foo_tgt = Target('foo')
bar_tgt = Target('bar')
spam_tgt = Target('spam')
spam_src = Source('eggs')
c1 = Command('foo', None, foo_tgt, x=bar_tgt, ssc=spam_src)
c1.add_other_dep(spam_tgt)
targets = c1.getTargets()
self.failUnless(foo_tgt in targets)
self.failUnless(bar_tgt in targets)
self.failUnless(spam_tgt in targets)
self.failIf(spam_src in targets)
c1 = Command('foo', None)
targets = c1.getTargets()
self.failUnlessEqual(targets, [])
def testcopy(self):
foo_tgt = Target('foo')
bar_tgt = Target('bar')
spam_src = Source('spam')
c1 = Command('foo', None, foo_tgt, x=bar_tgt, src=spam_src)
c2 = c1.copy()
self.failUnlessEqual(c1, c2)
self.failIfEqual(id(c1), id(c2))
func = lambda x: x
c2.func = func
self.failIfEqual(c1, c2)
c1.func = func
self.failUnlessEqual(c1, c2)
def test_get_source_cont(self):
foo_src = Source('foo')
bar_src = Source('bar')
spam_tgt = Target('spam')
c1 = Command('foo', None, foo_src, x=bar_src, src=spam_tgt)
sc = c1.source_containers
self.failUnlessEqual(len(sc), 2)
self.failUnless('foo' in sc)
self.failUnless('bar' in sc)
self.failIf('spam' in sc)
def testsetunusedtarget(self):
foo_tgt = Target('foo')
cmd = Command('foo', None, Target)
cmd.setunusedtarget(foo_tgt)
targets = cmd.getTargets()
self.failUnlessEqual(targets, [foo_tgt])
self.failUnlessRaises(Exception, cmd.setunusedtarget, foo_tgt)
cmd = Command('foo', None, Source)
self.failUnlessRaises(Exception, cmd.setunusedtarget, foo_tgt)
cmd.add_other_dep(foo_tgt)
self.failUnlessEqual(targets, [foo_tgt])
def testsetTarget(self):
cp = CommandPack(['comm'])
self.failUnlessEqual(cp.target, True)
cp.target = 'tgt'
self.failUnlessEqual(cp.target, 'tgt')
cmd = Command('tag', None)
cp = CommandPack([cmd], out_cont=None)
self.failUnlessRaises(Exception, setattr, cp, 'target', 'tgt')
cmd = Command('tag', None, Target)
cp = CommandPack([cmd], out_cont=None)
tgt = Target('tgt')
cp.target = tgt
self.failUnlessEqual(cp.target, None)
self.failUnlessEqual(cmd.getTargets(), [tgt])
def create_aug(self, other):
already_exists = other.container.has_built_meta_info()
cm = other.container.expand_meta()
lst = []
push = lst.append
for cont in cm:
push(Vector(cont))
aug_vec = AugVector(lst)
aug_vec.resize(self.kparams['num_blocks']) #IGNORE:E1101
aug_vec.meta = self.domain()
aug_vec.meta['num_blocks'] = self.kparams['num_blocks']
aug_vec.meta_vector = other
if already_exists:
return aug_vec
struct = Structure()
command = struct.generate_command('meta', Source(other.container),
**self.kparams)
# command.add_other_dep( )
for cont in cm:
command.add_other_dep(Target(cont))
converter = other.container.get_converter(command)
commpack = converter.convert(other, command)
commpack.target = None
commpack.source = None
self.env['graphmgr'].graphAppend(commpack)
return aug_vec
def scalar_reduction(cls, container, tag, *args, **kargs):
"""
generate a Scalar from a command
"""
scalar_methods = container.scalar_methods
scmd = scalar_methods.get_command(tag)
scalar = Scalar()
cont = Source(container)
scal = Target(scalar)
if cls.env['slimvars']['use_scalar_obj']:
command = general_command(tag, None, cont, scal, *args, **kargs)
# set command
command.func = scmd
compack = CommandPack([command], None, None)
cls.env['graphmgr'].graphAppend(compack)
else:
scalar = scal.data
return scalar
def gen_new_scal(self,other,func):
scalar = Scalar( )
trg_scal = Target( scalar )
src_self = Source( self )
other_obj = self._num_src( other )
# new_func = scalar_helper(func,func_name=func_name)
tag = str(func)
command = general_command( tag , None, src_self,other_obj,trg_scal )
command.func = func
if self.env['slimvars']['keep_tb_info']:
stack = traceback.extract_stack( )
st_list = traceback.format_list( stack[:-3] )
command.tb_info = "".join(st_list)
compack = CommandPack([command], None, None)
self.env['graphmgr'].graphAppend( compack )
return scalar