def __accumulate(self,func):
ranges={}
init=self[self.times[0]]
for k1,v1 in iteritems(init.data):
if k1=="time":
continue
ranges[k1]={}
for k2,v2 in iteritems(v1):
ranges[k1][k2]=v2
for t in self.times[1:]:
val=self[t]
for k1,v1 in iteritems(val.data):
if k1=="time":
continue
for k2,v2 in iteritems(v1):
old=ranges[k1][k2]
if self.entries[k1][k2]==1:
ranges[k1][k2]=func(old,v2)
else:
r=[]
for i in range(self.entries[k1][k2]):
r.append(func(old[i],v2[i]))
ranges[k1][k2]=r
return FunkyDoCalcData(ranges)
def modify(self, unique_id, data):
"""Modify a dataset for which we have a unique id with the data in a dictionary"""
update_run = self.get_runID(unique_id)
if update_run is None:
raise KeyError("Unique ID {} not in database".format(unique_id))
self.__adaptDatabase(data)
runData = dict([(k, v) for k, v in iteritems(data) if type(v) != dict])
runID = self.__addContent(self.TheRunsName,
runData,
update_run=update_run)
if update_run is not None:
runID = update_run
subtables = dict([(k, v) for k, v in iteritems(data)
if type(v) == dict])
for tn, content in iteritems(subtables):
self.__addContent(tn + "Data",
dict(
list(self.__flattenDict(content).items()) +
[(self.run_id, runID)]),
update_run=update_run)
self.db.commit()
def __accumulate(self, func):
ranges = {}
init = self[self.times[0]]
for k1, v1 in iteritems(init.data):
if k1 == "time":
continue
ranges[k1] = {}
for k2, v2 in iteritems(v1):
ranges[k1][k2] = v2
for t in self.times[1:]:
val = self[t]
for k1, v1 in iteritems(val.data):
if k1 == "time":
continue
for k2, v2 in iteritems(v1):
old = ranges[k1][k2]
if self.entries[k1][k2] == 1:
ranges[k1][k2] = func(old, v2)
else:
r = []
for i in range(self.entries[k1][k2]):
r.append(func(old[i], v2[i]))
ranges[k1][k2] = r
return FunkyDoCalcData(ranges)
def __init__(self):
"""Constructs the ConfigParser and fills it with the hardcoded defaults"""
configparser.ConfigParser.__init__(self)
for section,content in iteritems(_defaults):
self.add_section(section)
for key,value in iteritems(content):
self.set(section,key,str(value))
self.read(self.configFiles())
self.validSections={}
for s in self.sections():
minusPos=s.find('-')
if minusPos<0:
name=s
else:
name=s[:minusPos]
try:
self.validSections[name].append(s)
except KeyError:
self.validSections[name]=[s]
for name,sections in iteritems(self.validSections):
if not name in sections:
print("Invalid configuration for",name,"there is no default section for it in",sections)
def __init__(self):
"""Constructs the ConfigParser and fills it with the hardcoded defaults"""
configparser.ConfigParser.__init__(self)
for section, content in iteritems(_defaults):
self.add_section(section)
for key, value in iteritems(content):
self.set(section, key, str(value))
self.read(self.configFiles())
self.validSections = {}
for s in self.sections():
minusPos = s.find('-')
if minusPos < 0:
name = s
else:
name = s[:minusPos]
try:
self.validSections[name].append(s)
except KeyError:
self.validSections[name] = [s]
for name, sections in iteritems(self.validSections):
if not name in sections:
print("Invalid configuration for", name,
"there is no default section for it in", sections)
def __call__(self):
texts={}
for n,val in iteritems(self.templates):
template=TemplateFile(content=val,
expressionDelimiter="|-",
encoding="ascii")
try:
texts[n]=str(template.getString(self.runner.getData()))
except TemplateRenderError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
error("Template error",e,"while rendering",val)
msg=Message()
msg["To"]=self.sendTo
msg["From"]=self.sentFrom
msg["Subject"]=texts["subject"]
for n,v in iteritems(self.mailFields):
msg[n]=v
msg.set_payload(texts["message"])
print_("Connecting to SMTP-server",self.server)
try:
s=smtplib.SMTP(self.server)
except:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
error("Could not connect to",self.server,":",e)
print_("Sending mail")
r=s.sendmail(self.sentFrom,self.sendTo.split(","),msg.as_string())
print_("\n",self.name,"Sent mail to",self.sendTo," Response:",r)
# not yet tested with python3
def __flattenDict(self,oData,prefix=""):
data=[(prefix+k,v) for k,v in iteritems(oData) if type(v)!=dict]
subtables=dict([(k,v) for k,v in iteritems(oData) if type(v)==dict])
for name,val in iteritems(subtables):
data+=list(self.__flattenDict(val,prefix+name+self.separator).items())
if self.verbose:
print_("Flattened",oData,"to",data)
return dict(data)
def calcTolerances(self, digits):
from math import log10, floor, pow
def calcDigits(w):
try:
return int(floor(log10(w)))
except ValueError:
return -digits
tol = OrderedDict()
span = self.span
amax = self.absmax
def tolDict(span, amax):
try:
relspan = float(span) / amax
except ZeroDivisionError:
relspan = None
if span > amax: # Don't calc relative tolerance if min and max have different signs
relspan = None
return {
"abstol":
max(pow(10,
calcDigits(span) - digits),
pow(10,
calcDigits(amax) - digits)),
"reltol":
None if relspan is None else min(pow(10, calcDigits(relspan)),
pow(10, -digits)),
"valueRel":
True,
"spanRel":
True,
"amaxRel":
True,
"span":
span,
"amax":
amax,
"smallEps":
1e-15,
"allowZero":
False
}
for k, v in iteritems(self.entries):
t = OrderedDict()
for n, nr in iteritems(v):
s = span[k][n]
a = amax[k][n]
if nr == 1:
s = [s]
a = [a]
t[n] = [tolDict(*par) for par in zip(s, a)]
tol[k] = t
return {'tolerances': tol}
def add(self,data):
"""Add a dictionary with data to the database"""
self.__adaptDatabase(data)
runData=dict([("insertionTime",datetime.datetime.now())]+ \
[(k,v) for k,v in iteritems(data) if type(v)!=dict])
runID=self.__addContent("theRuns",runData)
subtables=dict([(k,v) for k,v in iteritems(data) if type(v)==dict])
for tn,content in iteritems(subtables):
self.__addContent(tn+"Data",
dict(list(self.__flattenDict(content).items())+
[("runId",runID)]))
self.db.commit()
def __denormalize(self, s):
"""Denormalize the column name that was normalized by _normalize"""
while s.find(RunDatabase.specialString) >= 0:
pre, post = s.split(RunDatabase.specialString, maxsplit=1)
spec = post[0:3]
for k, v in iteritems(RunDatabase.specialChars):
if spec == v:
s = pre + k + post[3:]
break
else:
error("No special character for encoding", spec, "found")
result = ""
underFound = False
for c in s:
if underFound:
underFound = False
result += c.upper()
elif c == "_":
underFound = True
else:
result += c
if underFound:
error("String", s, "was not correctly encoded")
return result
def parameterValues(self):
vals = {}
for k, v in iteritems(self.__parameters):
vals[k] = v["value"]
return vals
def dictkeyclean(d):
"""Convert all keys of the dict `d` to strings.
"""
new_d = {}
for k, v in iteritems(d):
new_d[str(k)] = v
return new_d
def makeReport(self,values,level=2,meta=None):
if meta is None:
meta=self.metaData
helper=RestructuredTextHelper(defaultHeading=level)
val=""
for k in meta:
if k=="":
if len(meta[k])==0:
continue
tab=helper.table(labeled=True)
for kk in meta[k]:
if "default" in meta[k][kk] and values[kk]!=meta[k][kk]["default"]:
changed=True
tab.addRow(helper.strong(kk))
else:
changed=False
tab.addRow(kk)
for a,v in iteritems(meta[k][kk]):
tab.addItem(a,v)
if changed:
tab.addItem("Value",helper.strong(values[kk]))
else:
tab.addItem("Value",values[kk])
val+=str(tab)
else:
descr,newMeta=meta[k]
val+=helper.heading(descr)
val+="\nShort name: "+helper.literal(k)+"\n"
val+=self.makeReport(values,
level=level+1,
meta=newMeta)
return val
def makeReport(self, values, level=2, meta=None):
if meta is None:
meta = self.metaData
helper = RestructuredTextHelper(defaultHeading=level)
val = ""
for k in meta:
if k == "":
if len(meta[k]) == 0:
continue
tab = helper.table(labeled=True)
for kk in meta[k]:
if "default" in meta[k][
kk] and values[kk] != meta[k][kk]["default"]:
changed = True
tab.addRow(helper.strong(kk))
else:
changed = False
tab.addRow(kk)
for a, v in iteritems(meta[k][kk]):
tab.addItem(a, v)
if changed:
tab.addItem("Value", helper.strong(values[kk]))
else:
tab.addItem("Value", values[kk])
val += str(tab)
else:
descr, newMeta = meta[k]
val += helper.heading(descr)
val += "\nShort name: " + helper.literal(k) + "\n"
val += self.makeReport(values, level=level + 1, meta=newMeta)
return val
def __call__(self):
if self.useSSL:
meth = httplib.HTTPSConnection
else:
meth = httplib.HTTPConnection
conn = meth(self.host)
parameters = {}
for n, val in iteritems(self.parameters):
if n in self.templates:
template = TemplateFile(content=val,
expressionDelimiter="|-",
encoding="ascii")
try:
parameters[n] = str(
template.getString(self.runner.getData()))
except TemplateRenderError:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
error("Template error", e, "while rendering", val)
else:
parameters[n] = val
encoded = urllib.urlencode(parameters)
try:
conn.request(self.method, self.url, encoded, self.headers)
except socket.error:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
error("Could not connect to", self.host, ":", e)
result = conn.getresponse()
print_("\n", self.name, "Result of request:", result.status,
result.reason, result.read())
def testDictProxy(self):
d=DictProxy()
d[2]=3
d["a"]=4
self.assertEqual(d[2],3)
self.assertEqual(d["a"],4)
self.assertEqual(len(d),2)
del d[2]
self.assertEqual(len(d),1)
d["b"]="nix"
self.assertEqual(len(d),2)
d["a"]=5
self.assertEqual(d["a"],5)
self.assertEqual(len(d),2)
cnt=0
for k,v in iteritems(d):
self.assertEqual(d[k],v)
cnt+=1
self.assertEqual(len(d),cnt)
self.assertEqual(d.keys(),['a','b'])
self.assertEqual(str(d),"{'a': 5, 'b': 'nix'}")
self.assertEqual(d.keys(),['a','b'])
d["c"]=2
self.assertEqual(d.keys(),['a','b','c'])
self.assertEqual(str(d),"{'a': 5, 'b': 'nix', 'c': 2}")
self.assertEqual(d.keys(),['a','b','c'])
def setData(self, data):
"""Set the application data
@param data: dictionary whose entries will be added to the
application data (possibly overwriting old entries of the same name)"""
for k, v in iteritems(data):
self.__appData[k] = deepcopy(v)
def endTest(self):
unused=[]
for k,v in iteritems(self.__parameters):
if not v["used"]:
unused.append(k)
if len(unused)>0:
self.warn("Unused parameters (possible typo):",unused)
print_()
if self.__failed:
print_("Test failed.")
print_()
print_("Summary of failures")
print_(self.__failMessage)
print_()
sys.exit(1)
else:
print_("Test successful")
print_()
if len(self.__failMessage)>0:
print_("Summary of warnings")
print_(self.__failMessage)
print_()
sys.exit(0)
def __addContent(self,table,data):
cursor=self.db.cursor()
runData={}
for k,v in iteritems(data):
if k=="runId":
runData[k]=v
elif isinstance(v,integer_types+(float,)):
runData[k]=float(v)
else:
runData[k]=uniCode(str(v))
cols=self.__getColumns(table)[1:]
addData=[]
for c in cols:
try:
addData.append(runData[c])
except KeyError:
addData.append(None)
addData=tuple(addData)
cSQL = "insert into "+table+" ("+ \
",".join(['"'+self.__normalize(c)+'"' for c in cols])+ \
") values ("+",".join(["?"]*len(addData))+")"
if self.verbose:
print_("Execute SQL",cSQL,"with",addData)
try:
cursor.execute(cSQL, addData)
except Exception:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
print_("SQL-Expression:",cSQL)
print_("AddData:",addData)
raise e
return cursor.lastrowid
def parameterValues(self):
vals={}
for k,v in iteritems(self.__parameters):
vals[k]=v["value"]
return vals
def addFunctionObjects(self,templateFile):
"""Add entries for libraries and functionObjects to the controlDict
(if they don't exist
@param templateFile: file withe the data that should be added
"""
tf=ParsedParameterFile(templateFile)
cd=self.controlDict()
touchedCD=False
if "libs" in tf:
touchedCD=True
if not "libs" in cd:
cd["libs"]=[]
for l in tf["libs"]:
if l in cd["libs"]:
self.warn(l,"already in 'libs' in the controlDict")
else:
cd["libs"].append(l)
if "functions" in tf:
touchedCD=True
if not "functions" in cd:
cd["functions"]={}
for k,v in iteritems(tf["functions"]):
if k in cd["functions"]:
self.warn("Overwriting function object",k)
cd["functions"][k]=v
if touchedCD:
cd.writeFile()
def setData(self,data):
"""Set the application data
@param data: dictionary whose entries will be added to the
application data (possibly overwriting old entries of the same name)"""
for k,v in iteritems(data):
self.__appData[k]=deepcopy(v)
def dictkeyclean(d):
"""Convert all keys of the dict `d` to strings.
"""
new_d = {}
for k, v in iteritems(d):
new_d[str(k)] = v
return new_d
def endTest(self):
unused = []
for k, v in iteritems(self.__parameters):
if not v["used"]:
unused.append(k)
if len(unused) > 0:
self.warn("Unused parameters (possible typo):", unused)
print_()
if self.__failed:
print_("Test failed.")
print_()
print_("Summary of failures")
print_(self.__failMessage)
print_()
sys.exit(1)
else:
print_("Test successful")
print_()
if len(self.__failMessage) > 0:
print_("Summary of warnings")
print_(self.__failMessage)
print_()
sys.exit(0)
def testDictProxy(self):
d=DictProxy()
d[2]=3
d["a"]=4
self.assertEqual(d[2],3)
self.assertEqual(d["a"],4)
self.assertEqual(len(d),2)
del d[2]
self.assertEqual(len(d),1)
d["b"]="nix"
self.assertEqual(len(d),2)
d["a"]=5
self.assertEqual(d["a"],5)
self.assertEqual(len(d),2)
cnt=0
for k,v in iteritems(d):
self.assertEqual(d[k],v)
cnt+=1
self.assertEqual(len(d),cnt)
self.assertEqual(d.keys(),['a','b'])
self.assertEqual(str(d),"{'a': 5, 'b': 'nix'}")
self.assertEqual(d.keys(),['a','b'])
d["c"]=2
self.assertEqual(d.keys(),['a','b','c'])
self.assertEqual(str(d),"{'a': 5, 'b': 'nix', 'c': 2}")
self.assertEqual(d.keys(),['a','b','c'])
def addFunctionObjects(self, templateFile):
"""Add entries for libraries and functionObjects to the controlDict
(if they don't exist
@param templateFile: file withe the data that should be added
"""
tf = ParsedParameterFile(templateFile)
cd = self.controlDict()
touchedCD = False
if "libs" in tf:
touchedCD = True
if not "libs" in cd:
cd["libs"] = []
for l in tf["libs"]:
if l in cd["libs"]:
self.warn(l, "already in 'libs' in the controlDict")
else:
cd["libs"].append(l)
if "functions" in tf:
touchedCD = True
if not "functions" in cd:
cd["functions"] = {}
for k, v in iteritems(tf["functions"]):
if k in cd["functions"]:
self.warn("Overwriting function object", k)
cd["functions"][k] = v
if touchedCD:
cd.writeFile()
def runPreHooks(self):
"""Run the hooks before the execution of the solver"""
if self.opts.runPreHook:
self.hookmessage("Running pre-hooks")
for h, spec in iteritems(self.preHookInstances):
self.executeHook(h, spec)
else:
self.hookmessage("Pre-hooks disabled")
def runPreHooks(self):
"""Run the hooks before the execution of the solver"""
if self.opts.runPreHook:
self.hookmessage("Running pre-hooks")
for h,spec in iteritems(self.preHookInstances):
self.executeHook(h,spec)
else:
self.hookmessage("Pre-hooks disabled")
def __adaptDatabase(self,data):
"""Make sure that all the required columns and tables are there"""
c=self.db.execute('SELECT name FROM sqlite_master WHERE type = "table"')
tables=[ x["name"] for x in c.fetchall() ]
indata=dict([(k,v) for k,v in iteritems(data) if type(v)!=dict])
subtables=dict([(k,v) for k,v in iteritems(data) if type(v)==dict])
self.__addColumnsToTable("theRuns",indata)
for tn,content in iteritems(subtables):
if tn+"Data" not in tables:
if self.verbose:
print_("Adding table",tn)
self.db.execute("CREATE TABLE "+tn+"Data (dataId INTEGER PRIMARY KEY, runId INTEGER)")
self.__addColumnsToTable(tn+"Data",
self.__flattenDict(content))
def runPostHooks(self):
"""Run the hooks after the execution of the solver"""
if self.opts.runPostHook:
self.hookmessage("Running post-hooks")
for h,spec in iteritems(self.postHookInstances):
self.executeHook(h,spec)
else:
self.hookmessage("Post-hooks disabled")
pass
def runPostHooks(self):
"""Run the hooks after the execution of the solver"""
if self.opts.runPostHook:
self.hookmessage("Running post-hooks")
for h, spec in iteritems(self.postHookInstances):
self.executeHook(h, spec)
else:
self.hookmessage("Post-hooks disabled")
pass
def prepareForTransfer(self):
"""Makes sure that the data about the plots is to be transfered via XMLRPC"""
lst={}
for i,p in iteritems(self.plots):
lst[str(i)]={ "nr" : i,
"spec" : p.spec.getDict(),
"id" : p.spec.id,
"data" : p.data.lineNr }
return lst
def calcTolerances(self,digits):
from math import log10,floor,pow
def calcDigits(w):
try:
return int(floor(log10(w)))
except ValueError:
return -digits
tol=OrderedDict()
span=self.span
amax=self.absmax
def tolDict(span,amax):
try:
relspan=float(span)/amax
except ZeroDivisionError:
relspan=None
if span>amax: # Don't calc relative tolerance if min and max have different signs
relspan=None
return { "abstol" : max(pow(10,calcDigits(span)-digits),
pow(10,calcDigits(amax)-digits)),
"reltol" : None if relspan is None else min(pow(10,calcDigits(relspan)),
pow(10,-digits)),
"valueRel" : True,
"spanRel" : True,
"amaxRel" : True,
"span" : span,
"amax" : amax ,
"smallEps" : 1e-15,
"allowZero" : False }
for k,v in iteritems(self.entries):
t=OrderedDict()
for n,nr in iteritems(v):
s=span[k][n]
a=amax[k][n]
if nr==1:
s=[s]
a=[a]
t[n]=[tolDict(*par) for par in zip(s,a)]
tol[k]=t
return {'tolerances':tol}
def __init__(self):
self._compile_cache = {}
self.locals_ptr = None
self.eval_allowed_globals = self.safe_builtins.copy()
if not PY3:
for k, d in iteritems(self.safe_builtins_python2):
self.eval_allowed_globals[k] = eval(d)
self.register("__import__", self.f_import)
self.register("exists", self.f_exists)
self.register("default", self.f_default)
self.register("setvar", self.f_setvar)
def __init__(self):
self._compile_cache = {}
self.locals_ptr = None
self.eval_allowed_globals = self.safe_builtins.copy()
if not PY3:
for k,d in iteritems(self.safe_builtins_python2):
self.eval_allowed_globals[k]=eval(d)
self.register("__import__", self.f_import)
self.register("exists", self.f_exists)
self.register("default", self.f_default)
self.register("setvar", self.f_setvar)
def __init__(self, fName):
self.__content = ParsedParameterFile(fName,
doMacroExpansion=True,
noHeader=True)
self.fName = fName
rawData = []
for k, v in iteritems(self.__content["data"]):
rawData.append((v["time"], v))
rawData.sort(key=lambda x: float(x[0]))
self.__data = OrderedDict()
self.entries = None
for k, v in rawData:
self.__data[k] = v
if self.entries is None:
self.entries = OrderedDict()
for k2, v2 in iteritems(v):
if k2 == "time":
continue
e = OrderedDict()
for k3, v3 in iteritems(v2):
try:
e[k3] = len(list(v3))
except TypeError:
e[k3] = 1
self.entries[k2] = e
else:
for k2, v2 in iteritems(v):
if k2 == "time":
continue
val = 0
for k3, v3 in iteritems(v2):
try:
val = len(list(v3))
except TypeError:
val = 1
if val != self.entries[k2][k3]:
error("Inconsistency in data for time", k,
": expected", self.entries[k2][k3],
"values for", k2, "/", k3, ". Got", val)
def __init__(self,fName):
self.__content=ParsedParameterFile(fName,
doMacroExpansion=True,
noHeader=True)
self.fName=fName
rawData=[]
for k,v in iteritems(self.__content["data"]):
rawData.append((v["time"],v))
rawData.sort(key=lambda x:float(x[0]))
self.__data=OrderedDict()
self.entries=None
for k,v in rawData:
self.__data[k]=v
if self.entries is None:
self.entries=OrderedDict()
for k2,v2 in iteritems(v):
if k2=="time":
continue
e=OrderedDict()
for k3,v3 in iteritems(v2):
try:
e[k3]=len(list(v3))
except TypeError:
e[k3]=1
self.entries[k2]=e
else:
for k2,v2 in iteritems(v):
if k2=="time":
continue
val=0
for k3,v3 in iteritems(v2):
try:
val=len(list(v3))
except TypeError:
val=1
if val!=self.entries[k2][k3]:
error("Inconsistency in data for time",k,
": expected",self.entries[k2][k3],"values for",
k2,"/",k3,". Got",val)
def getLatestData(self):
"""Return a dictionary with the latest values from all data sets"""
result={}
for n,d in iteritems(self.values):
if self.lastValid[n] or len(d)<2:
result[n]=d[-1]
else:
result[n]=d[-2]
return result
def patches(self, patchType=None):
"""Returns a list with the names of the patches
:param patchType: If specified only patches of the specific type are returned"""
if patchType == None:
return list(self.content.keys())
else:
result = []
for k, v in iteritems(self.content):
if v["type"] == patchType:
result.append(k)
return result
def getLatestData(self):
"""Return a dictionary with the latest values from all data sets"""
result = {}
for n, d in iteritems(self.values):
if self.lastValid[n] or len(d) < 2:
result[n] = d[-1]
else:
result[n] = d[-2]
return result
def patches(self,patchType=None):
"""Returns a list with the names of the patches
@param patchType: If specified only patches of the specific type are returned"""
if patchType==None:
return list(self.content.keys())
else:
result=[]
for k,v in iteritems(self.content):
if v["type"]==patchType:
result.append(k)
return result
def processKeywordArguments(self,kw):
kwArgs=self._buildKeyordArgumentList()
for k,v in iteritems(kw):
if k not in kwArgs:
raise TypeError("Unknown keyword argument",k,"in",
sorted(kwArgs.keys()))
o=kwArgs[k]
if o.action=="store_true":
if type(v)!=bool:
raise TypeError("Keyword argument",k,"needs a bool")
setattr(self.values,o.dest,v)
elif o.action=="store_false":
if type(v)!=bool:
raise TypeError("Keyword argument",k,"needs a bool")
setattr(self.values,o.dest,not v)
elif o.action=="store":
if o.type:
if o.type=="string":
if not isinstance(v,string_types) and v!=o.default and o.default!=None:
raise TypeError("Keyword argument",k,"must be string or",o.default,". Is a ",type(v))
elif o.type in ("int","long"):
if not isinstance(v,integer_types):
raise TypeError("Keyword argument",k,"must be an integer. Is a ",type(v))
elif o.type=="float":
if not isinstance(v,integer_types+(float,)):
raise TypeError("Keyword argument",k,"must be float. Is a ",type(v))
elif o.type=="choice":
if v not in o.choices:
raise TypeError("Keyword argument",k,"must be one of",o.choices)
else:
raise RuntimeError("Type",o.type,"not implemented")
setattr(self.values,o.dest,v)
elif o.action=="append":
oldVal=getattr(self.values,o.dest)
if type(oldVal) not in (list,tuple):
if not type(v) in (list,tuple):
raise TypeError("Keyword argument",k,"must be a list or a tuple")
setattr(self.values,o.dest,v)
else:
if type(v) in (list,tuple):
setattr(self.values,o.dest,oldVal+v)
else:
oldVal.append(v)
elif o.action=="store_const":
setattr(self.values,o.dest,o.const)
elif o.action=="append_const":
getattr(self.values,o.dest).append(o.const)
elif o.action=="count":
oldVal=getattr(self.values,o.dest)
setattr(self.values,o.dest,oldVal+1)
else:
raise RuntimeError("Action",o.action,"not implemented")
def processKeywordArguments(self,kw):
kwArgs=self._buildKeyordArgumentList()
for k,v in iteritems(kw):
if k not in kwArgs:
raise TypeError("Unknown keyword argument",k,"in",
sorted(kwArgs.keys()))
o=kwArgs[k]
if o.action=="store_true":
if type(v)!=bool:
raise TypeError("Keyword argument",k,"needs a bool")
setattr(self.values,o.dest,v)
elif o.action=="store_false":
if type(v)!=bool:
raise TypeError("Keyword argument",k,"needs a bool")
setattr(self.values,o.dest,not v)
elif o.action=="store":
if o.type:
if o.type=="string":
if not isinstance(v,string_types) and v!=o.default and o.default!=None:
raise TypeError("Keyword argument",k,"must be string or",o.default,". Is a ",type(v))
elif o.type in ("int","long"):
if not isinstance(v,integer_types):
raise TypeError("Keyword argument",k,"must be an integer. Is a ",type(v))
elif o.type=="float":
if not isinstance(v,integer_types+(float,)):
raise TypeError("Keyword argument",k,"must be float. Is a ",type(v))
elif o.type=="choice":
if v not in o.choices:
raise TypeError("Keyword argument",k,"must be one of",o.choices)
else:
raise RuntimeError("Type",o.type,"not implemented")
setattr(self.values,o.dest,v)
elif o.action=="append":
oldVal=getattr(self.values,o.dest)
if type(oldVal) not in (list,tuple):
if not type(v) in (list,tuple):
raise TypeError("Keyword argument",k,"must be a list or a tuple")
setattr(self.values,o.dest,v)
else:
if type(v) in (list,tuple):
setattr(self.values,o.dest,oldVal+v)
else:
oldVal.append(v)
elif o.action=="store_const":
setattr(self.values,o.dest,o.const)
elif o.action=="append_const":
getattr(self.values,o.dest).append(o.const)
elif o.action=="count":
oldVal=getattr(self.values,o.dest)
setattr(self.values,o.dest,oldVal+1)
else:
raise RuntimeError("Action",o.action,"not implemented")
def buildFilenameExtension(paraList, valueStrings):
ext = ""
if len(paraList) > 0:
ext = "_".join([path.basename(p) for p in paraList])
if len(valueStrings) > 0:
d = {}
for v in valueStrings:
d.update(eval(v))
ext += "_" + "_".join(["%s=%s" % (n, str(v)) for n, v in iteritems(d)])
if ext == "":
return "_vanilla"
else:
return "_" + ext
def __addColumnsToTable(self,table,data):
columns=self.__getColumns(table)
for k,v in iteritems(data):
if k not in columns:
if self.verbose:
print_("Adding:",k,"to",table)
if isinstance(v,integer_types+(float,)):
self.db.execute('ALTER TABLE "%s" ADD COLUMN "%s" REAL' %
(table,self.__normalize(k)))
else:
self.db.execute('ALTER TABLE "%s" ADD COLUMN "%s" TEXT' %
(table,self.__normalize(k)))
def buildFilenameExtension(paraList,valueStrings):
ext=""
if len(paraList)>0:
ext="_".join([path.basename(p) for p in paraList])
if len(valueStrings)>0:
d={}
for v in valueStrings:
d.update(eval(v))
ext+="_"+"_".join(["%s=%s" % (n,str(v)) for n,v in iteritems(d)])
if ext=="":
return "_vanilla"
else:
return "_"+ext
def setParameters(self,**kwargs):
"""Update the parameters with a set of keyword-arguments"""
if self.__parametersClosedForWriting:
self.warn("Tried to modify parameters after the initialization phase",
kwargs)
caller=inspect.stack()[1]
setter="Set by %s in %s line %d" % (caller[3],caller[1],caller[2])
for k,v in iteritems(kwargs):
self.__parameters[k]={"value":v,
"setter":setter,
"used":False}
def setParameters(self,**kwargs):
"""Update the parameters with a set of keyword-arguments"""
if self.__parametersClosedForWriting:
self.warn("Tried to modify parameters after the initialization phase",
kwargs)
caller=inspect.stack()[1]
setter="Set by %s in %s line %d" % (caller[3],caller[1],caller[2])
for k,v in iteritems(kwargs):
self.__parameters[k]={"value":v,
"setter":setter,
"used":False}
def getCurrentData(self, structured=False):
tData = GeneralLineAnalyzer.getCurrentData(self, structured=structured)
if structured:
from collections import defaultdict
vals = defaultdict(dict)
for k, v in iteritems(tData):
pos = k.rfind("_")
if pos > 0:
vals[k[:pos]][k[(pos + 1):]] = v
else:
vals[k]["residual"] = v
return vals
else:
return tData
def resolveSlaves(self):
"""Looks through all the registered lines and replaces integers with
the actual registered line"""
for i,p in iteritems(self.lines):
if len(p.slaves)>0:
slaves=[]
for s in p.slaves:
if type(s)==int:
try:
slaves.append(self.lines[s])
except KeyError:
error(s,"not a known data set:",list(self.lines.keys()))
else:
slaves.append(s)
p.slaves=slaves
def doOp(a,b):
result={}
for k,va in iteritems(a):
try:
vb=b[k]
try:
result[k]=op(va,vb)
except TypeError:
if hasattr(va,"keys"):
result[k]=doOp(va,vb)
else:
result[k]=[r if abs(r)>smallEps else 0.
for r in [op(aa,bb) for aa,bb in zip(va,vb)]]
except KeyError:
pass
return result
def getString(self,vals):
"""In the template, replaces all the strings between $$
with the evaluation of the expressions
@param vals: dictionary with the values
@returns: The string with the replaced expressions"""
symbols=vals.copy()
exp=re.compile("\$[^$\n]*\$")
for n,e in iteritems(self.expressions):
if n in vals:
error("Key",n,"already existing in",vals)
symbols[n]="("+str(e)+")"
keys=list(symbols.keys())
# keys.sort(lambda x,y:cmp(len(y),len(x)))
keys.sort(key=len,reverse=True)
input=self.template[:]
m=exp.search(input)
while m:
a,e=m.span()
pre=input[0:a]
post=input[e:]
mid=input[a+1:e-1]
old=""
while old!=mid:
old=mid
for k in keys:
if mid.find(k)>=0:
mid=mid.replace(k,str(symbols[k]))
break
try:
input=pre+str(eval(mid))+post
except ArithmeticError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
print_("Problem evaluating",mid)
raise e
m=exp.search(input)
return input
def __str__(self):
string="// File generated by PyFoam - sorry for the ugliness\n\n"
temp=[]
for k,v in iteritems(self.content):
temp.append((k,v))
temp.sort(key=lambda x:int(x[1]["startFace"]))
temp2=[]
for b in temp:
temp2.append(b[0])
temp2.append(b[1])
generator=FoamFileGenerator(temp2,header=self.header)
string+=str(generator)
return string
def processDefault(self,raw):
"""Process a dictionary and return a 'flattened' dictionary with the
values and a dictionary with the meta-data"""
values=OrderedDict()
meta=OrderedDict()
meta[""]={}
for k,v in iteritems(raw):
isNormal=True
if isinstance(v,(DictProxy,dict)):
if "description" in v:
if "default" in v:
if "values" in v:
self.warning(k+" has also a 'values'-entry. Might be a subgroup")
vMeta={}
for a in v:
if a=="description":
vMeta[a]=self.__strip(v[a])
else:
vMeta[a]=v[a]
meta[""][k]=vMeta
elif "values" in v:
isNormal=False
if isNormal:
if k in values:
self.error(k,"defined twice in defaults")
if not k in meta[""]:
meta[""][k]={"default":v}
values[k]=v
else:
values[k]=meta[""][k]["default"]
else:
pVal,pMeta=self.processDefault(v["values"])
meta[k]=(self.__strip(v["description"]),pMeta)
for a in pVal:
if a in values:
self.error(a,"already defined in sub-directory")
else:
values[a]=pVal[a]
return values,meta
