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