def _processReused(specnames,
specdict,
reuseterms,
indentstr='',
typestr='',
endstatementchar='',
parseFunc=idfn):
"""Process substitutions of reused terms."""
seenrepterms = [] # for new protected names (global to all spec names)
reused = {}.fromkeys(specnames)
reuseterms_inv = invertMap(reuseterms)
# establish order for reusable terms, in case of inter-dependencies
are_dependent = []
deps = {}
for origterm, rterm in reuseterms.items():
for _, rt in reuseterms.items():
if proper_match(origterm, rt):
if rterm not in are_dependent:
are_dependent.append(rterm)
try:
deps[rterm].append(rt)
except KeyError:
# new list
deps[rterm] = [rt]
order = remain(sorted(reuseterms.values()), are_dependent) + are_dependent
for specname in specnames:
reused[specname] = []
specstr = specdict[specname]
repeatkeys = []
for origterm, repterm in reuseterms.items():
# only add definitions if string found
if proper_match(specstr, origterm):
specstr = specstr.replace(origterm, repterm)
if repterm not in seenrepterms:
reused[specname].append([
indentstr, typestr + ' ' * (len(typestr) > 0), repterm,
" = ",
parseFunc(origterm), endstatementchar, "\n"
])
seenrepterms.append(repterm)
else:
# look for this term on second pass
repeatkeys.append(origterm)
if len(seenrepterms) > 0:
# don't bother with a second pass if specstr has not changed
for origterm in repeatkeys:
# second pass
repterm = reuseterms[origterm]
if proper_match(specstr, origterm):
specstr = specstr.replace(origterm, repterm)
if repterm not in seenrepterms:
seenrepterms.append(repterm)
reused[specname].append([
indentstr, typestr + ' ' * (len(typestr) > 0),
repterm, " = ",
parseFunc(origterm), endstatementchar, "\n"
])
# if replacement terms have already been used in the specifications
# and there are no occurrences of the terms meant to be replaced then
# just log the definitions that will be needed without replacing
# any strings.
if reused[specname] == [] and len(reuseterms) > 0:
for origterm, repterm in reuseterms.items():
# add definition if *replacement* string found in specs
if proper_match(specstr,
repterm) and repterm not in seenrepterms:
reused[specname].append([
indentstr, typestr + ' ' * (len(typestr) > 0), repterm,
" = ",
parseFunc(origterm), endstatementchar, "\n"
])
seenrepterms.append(repterm)
specdict[specname] = specstr
# add any dependencies for repeated terms to those that will get
# defined when functions are instantiated
for r in seenrepterms:
if r in are_dependent:
for repterm in deps[r]:
if repterm not in seenrepterms:
reused[specname].append([
indentstr, typestr + ' ' * (len(typestr) > 0),
repterm, " = ",
parseFunc(reuseterms_inv[repterm]),
endstatementchar, "\n"
])
seenrepterms.append(repterm)
# reuseterms may be automatically provided for a range of definitions
# that may or may not contain instances, and it's too inefficient to
# check in advance, so we'll not cause an error here if none show up.
# if len(seenrepterms) == 0 and len(reuseterms) > 0:
# print("Reuse terms expected:%r" % reuseterms)
# info(specdict)
# raise RuntimeError("Declared reusable term definitions did not match"
# " any occurrences in the specifications")
return (reused, specdict, seenrepterms, order)
dsc = DSfuncspec.recreate('c')
assert dsc.spec[0] == DSfuncspec_C.spec[0], " - FAILED"
print " - PASSED.\n"
print "\n============================================================="
print "Test: wrapping delimiters around call arguments"
print """ ... around first argument: wrapArgInCall(fs, 'initcond', '"')"""
fs = 'initcond(v,p)'
print fs, " -- wrapped to: ", wrapArgInCall(fs, 'initcond', '"'), "\n"
print """ ... around second argument: wrapArgInCall(fs,'initcond','"',argnums=[1])"""
print fs, " -- wrapped to: ", wrapArgInCall(
fs, 'initcond', '"', argnums=[1]), "\n"
print """ ... extra braces to both arguments: wrapArgInCall(fs,'initcond','[',']',[0,1])"""
print fs, " -- wrapped to: ", wrapArgInCall(fs, 'initcond', '[', ']',
[0, 1]), "\n"
print "\nTest combo of addArgToCalls and wrapArgInCall with embedded calls:"
fs2 = "1/zeta(y_rel(y,initcond(y)+initcond(z)),z-initcond(x))+zeta(0.)"
print fs2, "\n"
fs2_p = addArgToCalls(fs2, ['zeta', 'y_rel', 'initcond', 'nothing'], "p")
print " ** becomes **"
print fs2_p, "\n"
fs2_p = wrapArgInCall(fs2_p, 'initcond', '"')
print " ** becomes **"
print fs2_p
from PyDSTool.parseUtils import proper_match
s = '1 +abc13 + abc'
assert proper_match(s, 'abc')
assert not proper_match(s[:10], 'abc')
def _processReused(specnames, specdict, reuseterms, indentstr='',
typestr='', endstatementchar='', parseFunc=idfn):
"""Process substitutions of reused terms."""
seenrepterms = [] # for new protected names (global to all spec names)
reused = {}.fromkeys(specnames)
reuseterms_inv = invertMap(reuseterms)
# establish order for reusable terms, in case of inter-dependencies
are_dependent = []
deps = {}
for origterm, rterm in reuseterms.iteritems():
for _, rt in reuseterms.iteritems():
if proper_match(origterm, rt):
if rterm not in are_dependent:
are_dependent.append(rterm)
try:
deps[rterm].append(rt)
except KeyError:
# new list
deps[rterm] = [rt]
order = remain(reuseterms.values(), are_dependent) + are_dependent
for specname in specnames:
reused[specname] = []
specstr = specdict[specname]
repeatkeys = []
for origterm, repterm in reuseterms.iteritems():
# only add definitions if string found
if proper_match(specstr, origterm):
specstr = specstr.replace(origterm, repterm)
if repterm not in seenrepterms:
reused[specname].append([indentstr,
typestr + ' ' *
(len(typestr) > 0),
repterm, " = ",
parseFunc(origterm),
endstatementchar, "\n"])
seenrepterms.append(repterm)
else:
# look for this term on second pass
repeatkeys.append(origterm)
if len(seenrepterms) > 0:
# don't bother with a second pass if specstr has not changed
for origterm in repeatkeys:
# second pass
repterm = reuseterms[origterm]
if proper_match(specstr, origterm):
specstr = specstr.replace(origterm, repterm)
if repterm not in seenrepterms:
seenrepterms.append(repterm)
reused[specname].append([indentstr,
typestr + ' ' *
(len(typestr) > 0),
repterm, " = ",
parseFunc(origterm),
endstatementchar, "\n"])
# if replacement terms have already been used in the specifications
# and there are no occurrences of the terms meant to be replaced then
# just log the definitions that will be needed without replacing
# any strings.
if reused[specname] == [] and len(reuseterms) > 0:
for origterm, repterm in reuseterms.iteritems():
# add definition if *replacement* string found in specs
if proper_match(specstr, repterm) and repterm not in seenrepterms:
reused[specname].append([indentstr,
typestr + ' ' *
(len(typestr) > 0),
repterm, " = ",
parseFunc(origterm),
endstatementchar, "\n"])
seenrepterms.append(repterm)
specdict[specname] = specstr
# add any dependencies for repeated terms to those that will get
# defined when functions are instantiated
for r in seenrepterms:
if r in are_dependent:
for repterm in deps[r]:
if repterm not in seenrepterms:
reused[specname].append([indentstr,
typestr + ' ' *
(len(typestr) > 0),
repterm, " = ",
parseFunc(
reuseterms_inv[repterm]),
endstatementchar, "\n"])
seenrepterms.append(repterm)
# reuseterms may be automatically provided for a range of definitions
# that may or may not contain instances, and it's too inefficient to
# check in advance, so we'll not cause an error here if none show up.
# if len(seenrepterms) == 0 and len(reuseterms) > 0:
# print "Reuse terms expected:", reuseterms
# info(specdict)
# raise RuntimeError("Declared reusable term definitions did not match"
# " any occurrences in the specifications")
return (reused, specdict, seenrepterms, order)
def test_proper_match():
s = '1 +abc13 + abc'
assert proper_match(s, 'abc')
assert not proper_match(s[:10], 'abc')
def test_proper_match():
s = '1 +abc13 + abc'
assert proper_match(s, 'abc')
assert not proper_match(s[:10], 'abc')