def _setting(m: Manager) -> DRef:
nonlocal n1, n2, n3, n4
n1 = mkstage(m, {'a': '1'}, lambda i, t: 33)
n2 = mkstage(m, {'maman': n1})
n3 = mkstage(m, {'a': '1'}, lambda i, t: 42)
assert n1 == n3
return n2
def _setting(m: Manager) -> DRef:
nonlocal n1, n2, n3, n4
n1 = mkstage(m, {'a': '1'})
n2 = mkstage(m, {'b': '2'}) # this one should not be realized
n3 = mkstage(m, {'c': '3', 'maman': n1})
n4 = mkstage(m, {'c': '4', 'papa': n3}) # neither this one
return n3
def _setup(m):
nonlocal n1, n2, n3, toplevel
n1 = mkstage(m, {'a': 1})
n2 = mkstage(m, {'parent1': n1})
n3 = mkstage(m, {'parent2': n1})
toplevel = mkstage(m, {'n2': n2, 'n3': n3})
return toplevel
def _stage(m):
s1 = mkstage(m, {'name': '1', 'promise': [promise, 'artifact']})
s2 = mkstage(m, {
'name': '2',
'maman': s1,
'promise': [promise, 'artifact']
})
s3 = mkstage(m, {
'name': '3',
'papa': s2,
'promise': [promise, 'artifact']
})
return s3
def _setting(m: Manager, fullfill: bool) -> DRef:
n1 = mkstage(m, {'name': '1', 'promise': [promise, 'artifact']})
def _realize(b: Build):
o = build_outpath(b)
c = build_cattrs(b)
assert b.dref in c.promise
assert n1 in store_cattrs(c.maman, S).promise
assert build_path(b, c.promise) == join(o, 'uber-artifact')
assert build_path(b,
store_cattrs(c.maman,
S).promise) == build_path(
b, c.maman_promise)
if fullfill:
with open(build_path(b, c.promise), 'w') as f:
f.write('chickenpoop')
return mkdrv(m,
mkconfig({
'name': '2',
'maman': n1,
'promise': [promise, 'uber-artifact'],
'maman_promise': [n1, 'artifact']
}),
matcher=match_some(),
realizer=build_wrapper(_realize))
def test_realize_base(d) -> None:
with setup_storage2('test_realize_base') as (T, S):
m = Manager(storage(S))
mkstage(m, d)
dref = list(m.builders.values())[-1].dref
assert_valid_dref(dref)
assert len(list(store_rrefs(dref, mkcontext(), S))) == 0
rrefgs = list(m.builders.values())[-1].matcher(S, dref, mkcontext())
assert rrefgs is None
rrefg = mkrgroup(
dref, mkcontext(),
list(m.builders.values())[-1].realizer(S, dref, mkcontext(),
{})[0], S)
assert len(list(store_rrefs(dref, mkcontext(), S))) == 1
assert_valid_rref(rrefg[Tag('out')])
rrefgs2 = list(m.builders.values())[-1].matcher(S, dref, mkcontext())
assert rrefgs2 is not None
rrefg2 = rrefgs2[0]
assert rrefg == rrefg2
def _setting(m:Manager)->DRef:
n1=mkstage(m, {'name':'1', 'promise':[promise,'artifact']})
n2=mkstage(m, {'name':'2', 'promise':[promise,'artifact'],
'dict':{'d1':1} })
def _realize(b:Build):
o=build_outpath(b)
c=build_cattrs(b)
assert isrefpath(mklens(b).maman.promise.refpath)
assert isfile(mklens(b).papa.promise.syspath)
assert o in mklens(b).promise.syspath
assert o == mklens(b).syspath
assert mklens(b).papa.name.val == '2'
assert mklens(b).papa.dref == c.papa
with open(mklens(b).promise.syspath,'w') as f:
f.write('chickenpoop')
return mkdrv(m,
mkconfig({'name':'3', 'maman':n1, 'papa':n2,
'promise':[promise,'artifact'],
}),
matcher=match_some(),
realizer=build_wrapper(_realize))
def _stage(m, root):
drefs:dict={}
for n,deps in list(dag):
def _nondet(ngroup,tag,nn):
a=nondets[nn]
# note(str(({nn:(a,'[',ngroup,']')})))
return a[ngroup]
drefs[n]=mkstage(m,
config={'name':f'node_{n}',
'parents':[drefs[d] for d in deps]},
tagset=tss[n],
# nondet=lambda i,tag: nondets[n][i],
nondet=partial(_nondet,nn=n),
nmatch=nmatches[n])
return drefs[root]
def _setting1(m: Manager) -> DRef:
return mkstage(m, {'a': '1'}, lambda i, tag: 33, buildtime=False)
def _setting(m:Manager)->DRef:
n1=mkstage(m, {'name':'1', 'x':33, 'promise':[promise,'artifact']})
n2=mkstage(m, {'name':'2', 'papa':n1, 'dict':{'d1':1} })
n3=mkstage(m, {'name':'3', 'maman':n2 })
return n3
def _somenode(m):
return mkstage(m, {'a': 0})
def _setup(m):
nonlocal n1, n2, n3
n1 = mkstage(m, {'a': '1'})
n2 = mkstage(m, {'maman': n1}, _gen)
n3 = mkstage(m, {'papa': n2})
return n3
def _anothernode(m):
n1 = mkstage(m, {'a': 1})
n2 = _somenode(m)
n3 = mkstage(m, {'maman': n1, 'papa': n2})
return n3
def _node1(m: Manager) -> DRef:
return mkstage(m, {'name': '1'})
def _node3(m: Manager) -> DRef:
return mkstage(m, {'name': '3', 'maman': _node1(m)})
def _setup(m):
rref = realize(instantiate(mkstage, {'foo': 'bar'}))
n2 = mkstage(m, {'bogus': rref})
return n2
def _setup(m):
clo = instantiate(mkstage, {'foo': 'bar'})
return mkstage(m, {'bogus': clo.dref})
def _setting(m: Manager) -> DRef:
return mkstage(m, {'a': '1'})
def _setting(m: Manager) -> DRef:
n1 = mkstage(m, {'a': '1'})
n2 = mkstage(m, {'maman': n1})
return n2
def _setup_outer(m):
nonlocal rref_inner
rref_inner = realize(instantiate(_setup_inner, S=S))
return mkstage(m, {'baz': mklens(rref_inner, S=S).foo.val})
def _setup_inner(m):
return mkstage(m, {'foo': 'bar'})
def _setup(m):
derivs = instantiate_(m, _setup)
n2 = mkstage(m, {'bogus': derivs.dref})
return n2
def _setting(m: Manager) -> DRef:
nonlocal n1, n2
n1 = mkstage(m, {'a': '1'}, lambda i, tag: 33)
n2 = mkstage(m, {'maman': n1}, lambda i, tag: 42)
return n2
def _setting2(m: Manager) -> DRef:
return mkstage(m, {'a': '1'}, lambda i, tag: 42, buildtime=True)
