1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2021 EDF R&D
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU Lesser General Public
7 # License as published by the Free Software Foundation; either
8 # version 2.1 of the License.
10 # This library is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 # Lesser General Public License for more details.
15 # You should have received a copy of the GNU Lesser General Public
16 # License along with this library; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 Définit les outils d'interfaces normalisées de cas.
26 __author__ = "Jean-Philippe ARGAUD"
35 from daCore import Persistence
36 from daCore import PlatformInfo
37 from daCore import Templates
38 from daCore import Reporting
40 # ==============================================================================
41 class GenericCaseViewer(object):
43 Gestion des commandes de création d'une vue de cas
45 def __init__(self, __name="", __objname="case", __content=None, __object=None):
46 "Initialisation et enregistrement de l'entete"
47 self._name = str(__name)
48 self._objname = str(__objname)
50 self._switchoff = False
51 self._numobservers = 2
52 self._content = __content
53 self._object = __object
54 self._missing = """raise ValueError("This case requires beforehand to import or define the variable named <%s>. When corrected, remove this command, correct and uncomment the following one.")\n# """
55 def _append(self, *args):
56 "Transformation d'une commande individuelle en un enregistrement"
57 raise NotImplementedError()
58 def _extract(self, *args):
59 "Transformation d'enregistrement(s) en commande(s) individuelle(s)"
60 raise NotImplementedError()
61 def _finalize(self, __upa=None):
62 "Enregistrement du final"
63 __hasNotExecute = True
64 for l in self._lineSerie:
65 if "%s.execute"%(self._objname,) in l: __hasNotExecute = False
67 self._lineSerie.append("%s.execute()"%(self._objname,))
68 if __upa is not None and len(__upa)>0:
69 __upa = __upa.replace("ADD",str(self._objname))
70 self._lineSerie.append(__upa)
71 def _addLine(self, line=""):
72 "Ajoute un enregistrement individuel"
73 self._lineSerie.append(line)
74 def _get_objname(self):
76 def dump(self, __filename=None, __upa=None):
77 "Restitution normalisée des commandes"
79 __text = "\n".join(self._lineSerie)
81 if __filename is not None:
82 __file = os.path.abspath(__filename)
83 __fid = open(__file,"w")
87 def load(self, __filename=None, __content=None, __object=None):
88 "Chargement normalisé des commandes"
89 if __filename is not None and os.path.exists(__filename):
90 self._content = open(__filename, 'r').read()
91 elif __content is not None and type(__content) is str:
92 self._content = __content
93 elif __object is not None and type(__object) is dict:
94 self._object = copy.deepcopy(__object)
96 pass # use "self._content" from initialization
97 __commands = self._extract(self._content, self._object)
100 class _TUIViewer(GenericCaseViewer):
102 Établissement des commandes d'un cas ADAO TUI (Cas<->TUI)
104 def __init__(self, __name="", __objname="case", __content=None, __object=None):
105 "Initialisation et enregistrement de l'entete"
106 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
107 self._addLine("# -*- coding: utf-8 -*-")
108 self._addLine("#\n# Python script using ADAO TUI\n#")
109 self._addLine("from numpy import array, matrix")
110 self._addLine("from adao import adaoBuilder")
111 self._addLine("%s = adaoBuilder.New('%s')"%(self._objname, self._name))
112 if self._content is not None:
113 for command in self._content:
114 self._append(*command)
115 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
116 "Transformation d'une commande individuelle en un enregistrement"
117 if __command is not None and __keys is not None and __local is not None:
118 if "Concept" in __keys:
119 logging.debug("TUI Order processed: %s"%(__local["Concept"],))
121 if __pre is not None:
122 __text += "%s = "%__pre
123 __text += "%s.%s( "%(self._objname,str(__command))
124 if "self" in __keys: __keys.remove("self")
125 if __command not in ("set","get") and "Concept" in __keys: __keys.remove("Concept")
127 if k not in __local: continue
129 if __v is None: continue
130 if k == "Checked" and not __v: continue
131 if k == "Stored" and not __v: continue
132 if k == "ColMajor" and not __v: continue
133 if k == "InputFunctionAsMulti" and not __v: continue
134 if k == "nextStep" and not __v: continue
135 if k == "AvoidRC" and __v: continue
136 if k == "noDetails": continue
137 if isinstance(__v,Persistence.Persistence): __v = __v.values()
138 if callable(__v): __text = self._missing%__v.__name__+__text
139 if isinstance(__v,dict):
140 for val in __v.values():
141 if callable(val): __text = self._missing%val.__name__+__text
142 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
143 __text += "%s=%s, "%(k,repr(__v))
144 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
145 __text = __text.rstrip(", ")
147 self._addLine(__text)
148 def _extract(self, __multilines="", __object=None):
149 "Transformation d'enregistrement(s) en commande(s) individuelle(s)"
152 __multilines = __multilines.replace("\r\n","\n")
153 for line in __multilines.split("\n"):
154 if "adaoBuilder.New" in line and "=" in line:
155 self._objname = line.split("=")[0].strip()
157 logging.debug("TUI Extracting commands of '%s' object..."%(self._objname,))
161 if self._objname+".set" in line:
162 __commands.append( line.replace(self._objname+".","",1) )
163 logging.debug("TUI Extracted command: %s"%(__commands[-1],))
166 class _COMViewer(GenericCaseViewer):
168 Établissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM)
170 def __init__(self, __name="", __objname="case", __content=None, __object=None):
171 "Initialisation et enregistrement de l'entete"
172 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
173 self._observerIndex = 0
174 self._addLine("# -*- coding: utf-8 -*-")
175 self._addLine("#\n# Python script using ADAO COMM\n#")
176 self._addLine("from numpy import array, matrix")
178 self._addLine("%s = {}"%__objname)
179 if self._content is not None:
180 for command in self._content:
181 self._append(*command)
182 def _extract(self, __multilines=None, __object=None):
183 "Transformation d'enregistrement(s) en commande(s) individuelle(s)"
184 __suppparameters = {}
185 if __multilines is not None:
186 if 'adaoBuilder' in __multilines:
187 raise ValueError("Impossible to load given content as an ADAO COMM one (Hint: it's perhaps not a COMM input, but a TUI one).")
188 if "ASSIMILATION_STUDY" in __multilines:
189 __suppparameters.update({'StudyType':"ASSIMILATION_STUDY"})
190 __multilines = __multilines.replace("ASSIMILATION_STUDY","dict")
191 elif "OPTIMIZATION_STUDY" in __multilines:
192 __suppparameters.update({'StudyType':"ASSIMILATION_STUDY"})
193 __multilines = __multilines.replace("OPTIMIZATION_STUDY", "dict")
194 elif "REDUCTION_STUDY" in __multilines:
195 __suppparameters.update({'StudyType':"ASSIMILATION_STUDY"})
196 __multilines = __multilines.replace("REDUCTION_STUDY", "dict")
197 elif "CHECKING_STUDY" in __multilines:
198 __suppparameters.update({'StudyType':"CHECKING_STUDY"})
199 __multilines = __multilines.replace("CHECKING_STUDY", "dict")
201 __multilines = __multilines.replace("ASSIMILATION_STUDY","dict")
203 __multilines = __multilines.replace("_F(", "dict(")
204 __multilines = __multilines.replace(",),);", ",),)")
206 for line in __multilines.split("\n"):
207 if len(line) < 1: continue
208 __fulllines += line + "\n"
209 __multilines = __fulllines
210 self._objname = "case"
212 exec("self._objdata = "+__multilines)
214 if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata):
215 raise ValueError("Impossible to load given content as an ADAO COMM one (no dictionnary or no 'AlgorithmParameters' key found).")
216 # ----------------------------------------------------------------------
217 logging.debug("COMM Extracting commands of '%s' object..."%(self._objname,))
219 __UserPostAnalysis = ""
220 for k,r in self._objdata.items():
222 logging.debug("COMM Extracted command: %s:%s"%(k, r))
223 if __command == "StudyName" and len(str(r))>0:
224 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
225 elif __command == "StudyRepertory":
226 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
227 elif __command == "Debug" and str(r) == "0":
228 __commands.append( "set( Concept='NoDebug' )" )
229 elif __command == "Debug" and str(r) == "1":
230 __commands.append( "set( Concept='Debug' )" )
231 elif __command == "ExecuteInContainer":
232 __suppparameters.update({'ExecuteInContainer':r})
234 elif __command == "UserPostAnalysis" and type(r) is dict:
236 __UserPostAnalysis = r['STRING'].replace("ADD",str(self._objname))
237 __commands.append( "set( Concept='UserPostAnalysis', String=\"\"\"%s\"\"\" )"%(__UserPostAnalysis,) )
238 elif 'SCRIPT_FILE' in r and os.path.exists(r['SCRIPT_FILE']):
239 __UserPostAnalysis = open(r['SCRIPT_FILE'],'r').read()
240 __commands.append( "set( Concept='UserPostAnalysis', Script='%s' )"%(r['SCRIPT_FILE'],) )
241 elif 'Template' in r and not 'ValueTemplate' in r:
243 if r['Template'] not in Templates.UserPostAnalysisTemplates:
244 raise ValueError("User post-analysis template \"%s\" does not exist."%(r['Template'],))
246 __UserPostAnalysis = Templates.UserPostAnalysisTemplates[r['Template']]
247 __commands.append( "set( Concept='UserPostAnalysis', Template='%s' )"%(r['Template'],) )
248 elif 'Template' in r and 'ValueTemplate' in r:
249 # Le template ayant pu être modifié, donc on ne prend que le ValueTemplate...
250 __UserPostAnalysis = r['ValueTemplate']
251 __commands.append( "set( Concept='UserPostAnalysis', String=\"\"\"%s\"\"\" )"%(__UserPostAnalysis,) )
253 __UserPostAnalysis = ""
255 elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
256 if 'data' in r and r['Parameters'] == 'Dict':
258 if 'STRING' in __from:
259 __parameters = ", Parameters=%s"%(repr(eval(__from['STRING'])),)
260 elif 'SCRIPT_FILE' in __from and os.path.exists(__from['SCRIPT_FILE']):
261 __parameters = ", Script='%s'"%(__from['SCRIPT_FILE'],)
262 else: # if 'Parameters' in r and r['Parameters'] == 'Defaults':
263 __Dict = copy.deepcopy(r)
264 __Dict.pop('Algorithm','')
265 __Dict.pop('Parameters','')
266 if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed'])
267 if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
268 __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
270 __parameters = ', Parameters=%s'%(repr(__Dict),)
273 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
275 elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
276 if type(r['SELECTION']) is str:
277 __selection = (r['SELECTION'],)
279 __selection = tuple(r['SELECTION'])
280 for sk in __selection:
281 __idata = r['%s_data'%sk]
282 if __idata['NodeType'] == 'Template' and 'Template' in __idata:
283 __template = __idata['Template']
284 if 'Info' in __idata:
285 __info = ", Info=\"\"\"%s\"\"\""%(__idata['Info'],)
288 __commands.append( "set( Concept='Observer', Variable='%s', Template=\"\"\"%s\"\"\"%s )"%(sk,__template,__info) )
289 if __idata['NodeType'] == 'String' and 'Value' in __idata:
290 __value =__idata['Value']
291 __commands.append( "set( Concept='Observer', Variable='%s', String=\"\"\"%s\"\"\" )"%(sk,__value) )
293 # Background, ObservationError, ObservationOperator...
294 elif type(r) is dict:
296 if 'Stored' in r and bool(r['Stored']):
297 __argumentsList.append(['Stored',True])
298 if 'INPUT_TYPE' in r and 'data' in r:
299 # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
300 __itype = r['INPUT_TYPE']
302 if 'FROM' in __idata:
303 # String, Script, DataFile, Template, ScriptWithOneFunction, ScriptWithFunctions
304 __ifrom = __idata['FROM']
305 __idata.pop('FROM','')
306 if __ifrom == 'String' or __ifrom == 'Template':
307 __argumentsList.append([__itype,__idata['STRING']])
308 if __ifrom == 'Script':
309 __argumentsList.append([__itype,True])
310 __argumentsList.append(['Script',__idata['SCRIPT_FILE']])
311 if __ifrom == 'DataFile':
312 __argumentsList.append([__itype,True])
313 __argumentsList.append(['DataFile',__idata['DATA_FILE']])
314 if __ifrom == 'ScriptWithOneFunction':
315 __argumentsList.append(['OneFunction',True])
316 __argumentsList.append(['Script',__idata.pop('SCRIPTWITHONEFUNCTION_FILE')])
318 __argumentsList.append(['Parameters',__idata])
319 if __ifrom == 'ScriptWithFunctions':
320 __argumentsList.append(['ThreeFunctions',True])
321 __argumentsList.append(['Script',__idata.pop('SCRIPTWITHFUNCTIONS_FILE')])
323 __argumentsList.append(['Parameters',__idata])
324 __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList]
325 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
327 __commands.append( "set( Concept='%s', Parameters=%s )"%('SupplementaryParameters', repr(__suppparameters)))
329 # ----------------------------------------------------------------------
330 __commands.sort() # Pour commencer par 'AlgorithmParameters'
331 __commands.append(__UserPostAnalysis)
334 class _SCDViewer(GenericCaseViewer):
336 Établissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
338 Remarque : le fichier généré est différent de celui obtenu par EFICAS
340 def __init__(self, __name="", __objname="case", __content=None, __object=None):
341 "Initialisation et enregistrement de l'entête"
342 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
344 if __content is not None:
345 for command in __content:
346 if command[0] == "set": __command = command[2]["Concept"]
347 else: __command = command[0].replace("set", "", 1)
348 if __command == 'Name':
349 self._name = command[2]["String"]
351 self.__DebugCommandNotSet = True
352 self.__ObserverCommandNotSet = True
353 self.__UserPostAnalysisNotSet = True
355 self._addLine("# -*- coding: utf-8 -*-")
356 self._addLine("#\n# Input for ADAO converter to SCD\n#")
358 self._addLine("study_config = {}")
359 self._addLine("study_config['Name'] = '%s'"%self._name)
361 self._addLine("inputvariables_config = {}")
362 self._addLine("inputvariables_config['Order'] =['adao_default']")
363 self._addLine("inputvariables_config['adao_default'] = -1")
364 self._addLine("study_config['InputVariables'] = inputvariables_config")
366 self._addLine("outputvariables_config = {}")
367 self._addLine("outputvariables_config['Order'] = ['adao_default']")
368 self._addLine("outputvariables_config['adao_default'] = -1")
369 self._addLine("study_config['OutputVariables'] = outputvariables_config")
370 if __content is not None:
371 for command in __content:
372 self._append(*command)
373 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
374 "Transformation d'une commande individuelle en un enregistrement"
375 if __command == "set": __command = __local["Concept"]
376 else: __command = __command.replace("set", "", 1)
377 logging.debug("SCD Order processed: %s"%(__command))
380 if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
382 elif __command in ['Directory',]:
383 __text = "#\nstudy_config['Repertory'] = %s"%(repr(__local['String']))
384 elif __command in ['Debug', 'setDebug']:
385 __text = "#\nstudy_config['Debug'] = '1'"
386 self.__DebugCommandNotSet = False
387 elif __command in ['NoDebug', 'setNoDebug']:
388 __text = "#\nstudy_config['Debug'] = '0'"
389 self.__DebugCommandNotSet = False
390 elif __command in ['Observer', 'setObserver']:
391 if self.__ObserverCommandNotSet:
392 self._addLine("observers = {}")
393 self._addLine("study_config['Observers'] = observers")
394 self.__ObserverCommandNotSet = False
395 __obs = __local['Variable']
396 self._numobservers += 1
398 __text += "observers['%s'] = {}\n"%__obs
399 if __local['String'] is not None:
400 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
401 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
402 if __local['Script'] is not None:
403 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
404 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
405 if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
406 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
407 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
408 if __local['Info'] is not None:
409 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
411 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
412 __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
413 elif __command in ['UserPostAnalysis', 'setUserPostAnalysis']:
415 __text += "Analysis_config = {}\n"
416 if __local['String'] is not None:
417 __text += "Analysis_config['From'] = 'String'\n"
418 __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(__local['String'],)
419 if __local['Script'] is not None:
420 __text += "Analysis_config['From'] = 'Script'\n"
421 __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(__local['Script'],)
422 if __local['Template'] is not None and __local['Template'] in Templates.UserPostAnalysisTemplates:
423 __text += "Analysis_config['From'] = 'String'\n"
424 __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(Templates.UserPostAnalysisTemplates[__local['Template']],)
425 __text += "study_config['UserPostAnalysis'] = Analysis_config"
426 self.__UserPostAnalysisNotSet = False
427 elif __local is not None: # __keys is not None and
428 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
430 __text += "%s_config = {}\n"%__command
431 __local.pop('self','')
433 __vectorIsDataFile = False
434 __vectorIsScript = False
435 for __k,__v in __local.items():
436 if __v is None: __to_be_removed.append(__k)
437 for __k in __to_be_removed:
439 for __k,__v in __local.items():
440 if __k == "Concept": continue
441 if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local and __local['Script'] is not None: continue
442 if __k in ['Vector','VectorSerie'] and 'DataFile' in __local and __local['DataFile'] is not None: continue
443 if __k == 'Parameters' and not (__command in ['AlgorithmParameters','SupplementaryParameters']): continue
444 if __k == 'Algorithm':
445 __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
446 elif __k == 'DataFile':
449 __v = "'"+repr(__v)+"'"
450 for __lk in ['Vector','VectorSerie']:
451 if __lk in __local and __local[__lk]: __k = __lk
452 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
453 __text += "%s_config['From'] = '%s'\n"%(__command,__f)
454 __text += "%s_config['Data'] = %s\n"%(__command,__v)
455 __text = __text.replace("''","'")
456 __vectorIsDataFile = True
457 elif __k == 'Script':
460 __v = "'"+repr(__v)+"'"
461 for __lk in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix']:
462 if __lk in __local and __local[__lk]: __k = __lk
463 if __command == "AlgorithmParameters": __k = "Dict"
464 if 'OneFunction' in __local and __local['OneFunction']:
465 __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
466 __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
467 __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
468 __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command,__v)
469 __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command,__v)
470 __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command,__v)
471 __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
472 __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
474 __f = 'ScriptWithOneFunction'
475 __v = '%s_ScriptWithOneFunction'%(__command,)
476 if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
477 __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
478 __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
479 __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
480 __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command,__v)
481 __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command,__v)
482 __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command,__v)
484 __f = 'ScriptWithFunctions'
485 __v = '%s_ScriptWithFunctions'%(__command,)
486 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
487 __text += "%s_config['From'] = '%s'\n"%(__command,__f)
488 __text += "%s_config['Data'] = %s\n"%(__command,__v)
489 __text = __text.replace("''","'")
490 __vectorIsScript = True
491 elif __k in ('Stored', 'Checked', 'ColMajor', 'InputFunctionAsMulti', 'nextStep'):
493 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
494 elif __k in ('AvoidRC', 'noDetails'):
496 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
498 if __k == 'Vector' and __vectorIsScript: continue
499 if __k == 'Vector' and __vectorIsDataFile: continue
500 if __k == 'Parameters': __k = "Dict"
501 if isinstance(__v,Persistence.Persistence): __v = __v.values()
502 if callable(__v): __text = self._missing%__v.__name__+__text
503 if isinstance(__v,dict):
504 for val in __v.values():
505 if callable(val): __text = self._missing%val.__name__+__text
506 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
507 __text += "%s_config['From'] = '%s'\n"%(__command,'String')
508 __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command,repr(__v))
509 __text += "study_config['%s'] = %s_config"%(__command,__command)
510 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
512 self._switchoff = True
513 if __text is not None: self._addLine(__text)
515 self._switchoff = False
516 def _finalize(self, *__args):
517 self.__loadVariablesByScript()
518 if self.__DebugCommandNotSet:
519 self._addLine("#\nstudy_config['Debug'] = '0'")
520 if self.__UserPostAnalysisNotSet:
522 self._addLine("Analysis_config = {}")
523 self._addLine("Analysis_config['From'] = 'String'")
524 self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
525 self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])")
526 self._addLine("print('Analysis:',xa)\"\"\"")
527 self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
528 def __loadVariablesByScript(self):
529 __ExecVariables = {} # Necessaire pour recuperer la variable
530 exec("\n".join(self._lineSerie), __ExecVariables)
531 study_config = __ExecVariables['study_config']
532 # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
533 if 'Algorithm' in study_config:
534 self.__hasAlgorithm = True
536 self.__hasAlgorithm = False
537 if not self.__hasAlgorithm and \
538 "AlgorithmParameters" in study_config and \
539 isinstance(study_config['AlgorithmParameters'], dict) and \
540 "From" in study_config['AlgorithmParameters'] and \
541 "Data" in study_config['AlgorithmParameters'] and \
542 study_config['AlgorithmParameters']['From'] == 'Script':
543 __asScript = study_config['AlgorithmParameters']['Data']
544 __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
545 __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
546 self._addLine(__text)
547 if self.__hasAlgorithm and \
548 "AlgorithmParameters" in study_config and \
549 isinstance(study_config['AlgorithmParameters'], dict) and \
550 "From" not in study_config['AlgorithmParameters'] and \
551 "Data" not in study_config['AlgorithmParameters']:
553 __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
554 __text += "AlgorithmParameters_config['From'] = 'String'\n"
555 __text += "AlgorithmParameters_config['Data'] = '{}'\n"
556 self._addLine(__text)
557 if 'SupplementaryParameters' in study_config and \
558 isinstance(study_config['SupplementaryParameters'], dict) and \
559 "From" in study_config['SupplementaryParameters'] and \
560 study_config['SupplementaryParameters']["From"] == 'String' and \
561 "Data" in study_config['SupplementaryParameters']:
562 __dict = eval(study_config['SupplementaryParameters']["Data"])
563 if 'ExecuteInContainer' in __dict:
564 self._addLine("#\nstudy_config['ExecuteInContainer'] = '%s'"%__dict['ExecuteInContainer'])
566 self._addLine("#\nstudy_config['ExecuteInContainer'] = 'No'")
567 if 'StudyType' in __dict:
568 self._addLine("#\nstudy_config['StudyType'] = '%s'"%__dict['StudyType'])
569 if 'StudyType' in __dict and __dict['StudyType'] != "ASSIMILATION_STUDY":
570 self.__UserPostAnalysisNotSet = False
573 class _YACSViewer(GenericCaseViewer):
575 Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
577 def __init__(self, __name="", __objname="case", __content=None, __object=None):
578 "Initialisation et enregistrement de l'entete"
579 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
580 self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
581 self._append = self.__internalSCD._append
582 def dump(self, __filename=None, __upa=None):
583 "Restitution normalisée des commandes"
585 if __filename is None:
586 raise ValueError("A file name has to be given for YACS XML output.")
588 __file = os.path.abspath(__filename)
589 if os.path.isfile(__file) or os.path.islink(__file):
592 if not PlatformInfo.has_salome or \
593 not PlatformInfo.has_adao:
595 "Unable to get SALOME or ADAO environnement for YACS conversion.\n"+\
596 "Please load the right SALOME environnement before trying to use it.")
598 from daYacsSchemaCreator.run import create_schema_from_content
600 self.__internalSCD._finalize(__upa)
601 __SCDdump = self.__internalSCD.dump()
602 create_schema_from_content(__SCDdump, __file)
604 if not os.path.exists(__file):
605 __msg = "An error occured during the ADAO YACS Schema build for\n"
606 __msg += "the target output file:\n"
607 __msg += " %s\n"%__file
608 __msg += "See errors details in your launching terminal log.\n"
609 raise ValueError(__msg)
611 __fid = open(__file,"r")
612 __text = __fid.read()
616 # ==============================================================================
617 class _ReportViewer(GenericCaseViewer):
619 Partie commune de restitution simple
621 def __init__(self, __name="", __objname="case", __content=None, __object=None):
622 "Initialisation et enregistrement de l'entete"
623 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
624 self._r = Reporting.ReportStorage()
627 self._r.append("ADAO Study report", "title")
629 self._r.append(str(self._name), "title")
630 if self._content is not None:
631 for command in self._content:
632 self._append(*command)
633 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
634 "Transformation d'une commande individuelle en un enregistrement"
635 if __command is not None and __keys is not None and __local is not None:
636 if __command in ("set","get") and "Concept" in __keys: __command = __local["Concept"]
638 __text += "<i>%s</i> command has been set"%str(__command.replace("set",""))
641 if k not in __local: continue
643 if __v is None: continue
644 if k == "Checked" and not __v: continue
645 if k == "Stored" and not __v: continue
646 if k == "ColMajor" and not __v: continue
647 if k == "InputFunctionAsMulti" and not __v: continue
648 if k == "nextStep" and not __v: continue
649 if k == "AvoidRC" and __v: continue
650 if k == "noDetails": continue
651 if k == "Concept": continue
652 if k == "self": continue
653 if isinstance(__v,Persistence.Persistence): __v = __v.values()
654 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
655 __ktext += "\n %s = %s, "%(k,repr(__v))
656 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
658 __text += " with values:" + __ktext
659 __text = __text.rstrip(", ")
660 self._r.append(__text, "uli")
661 def _finalize(self, __upa=None):
662 "Enregistrement du final"
663 raise NotImplementedError()
665 class _SimpleReportInRstViewer(_ReportViewer):
667 Restitution simple en RST
669 def _finalize(self, __upa=None):
670 self._lineSerie.append(Reporting.ReportViewInRst(self._r).__str__())
672 class _SimpleReportInHtmlViewer(_ReportViewer):
674 Restitution simple en HTML
676 def _finalize(self, __upa=None):
677 self._lineSerie.append(Reporting.ReportViewInHtml(self._r).__str__())
679 class _SimpleReportInPlainTxtViewer(_ReportViewer):
681 Restitution simple en TXT
683 def _finalize(self, __upa=None):
684 self._lineSerie.append(Reporting.ReportViewInPlainTxt(self._r).__str__())
686 # ==============================================================================
687 class ImportFromScript(object):
689 Obtention d'une variable nommee depuis un fichier script importé
691 __slots__ = ("__basename", "__filenspace", "__filestring")
692 def __init__(self, __filename=None):
693 "Verifie l'existence et importe le script"
694 if __filename is None:
695 raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
696 if not os.path.isfile(__filename):
697 raise ValueError("The file containing the variable to be imported doesn't seem to exist. Please check the file. The given file name is:\n \"%s\""%str(__filename))
698 if os.path.dirname(__filename) != '':
699 sys.path.insert(0, os.path.dirname(__filename))
700 __basename = os.path.basename(__filename).rstrip(".py")
702 __basename = __filename.rstrip(".py")
703 PlatformInfo.checkFileNameImportability( __basename+".py" )
704 self.__basename = __basename
706 self.__filenspace = __import__(__basename, globals(), locals(), [])
708 self.__filenspace = ""
709 with open(__filename,'r') as fid:
710 self.__filestring = fid.read()
711 def getvalue(self, __varname=None, __synonym=None ):
712 "Renvoie la variable demandee par son nom ou son synonyme"
713 if __varname is None:
714 raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
715 if not hasattr(self.__filenspace, __varname):
716 if __synonym is None:
717 raise ValueError("The imported script file \"%s\" doesn't contain the mandatory variable \"%s\" to be read. Please check the content of the file and the syntax."%(str(self.__basename)+".py",__varname))
718 elif not hasattr(self.__filenspace, __synonym):
719 raise ValueError("The imported script file \"%s\" doesn't contain the mandatory variable \"%s\" to be read. Please check the content of the file and the syntax."%(str(self.__basename)+".py",__synonym))
721 return getattr(self.__filenspace, __synonym)
723 return getattr(self.__filenspace, __varname)
725 "Renvoie le script complet"
726 return self.__filestring
728 # ==============================================================================
729 class ImportDetector(object):
731 Détection des caractéristiques de fichiers ou objets en entrée
734 "__url", "__usr", "__root", "__end")
735 def __enter__(self): return self
736 def __exit__(self, exc_type, exc_val, exc_tb): return False
738 def __init__(self, __url, UserMime=""):
740 raise ValueError("The name or url of the file object has to be specified.")
742 self.__url = __url.decode()
744 self.__url = str(__url)
745 if UserMime is bytes:
746 self.__usr = UserMime.decode().lower()
748 self.__usr = str(UserMime).lower()
749 (self.__root, self.__end) = os.path.splitext(self.__url)
751 mimetypes.add_type('application/numpy.npy', '.npy')
752 mimetypes.add_type('application/numpy.npz', '.npz')
753 mimetypes.add_type('application/dymola.sdf', '.sdf')
754 if sys.platform.startswith("win"):
755 mimetypes.add_type('text/plain', '.txt')
756 mimetypes.add_type('text/csv', '.csv')
757 mimetypes.add_type('text/tab-separated-values', '.tsv')
761 def is_local_file(self):
762 if os.path.isfile(os.path.realpath(self.__url)):
766 def is_not_local_file(self):
767 if not os.path.isfile(os.path.realpath(self.__url)):
771 def raise_error_if_not_local_file(self):
772 if not os.path.isfile(os.path.realpath(self.__url)):
773 raise ValueError("The name or the url of the file object doesn't seem to exist. The given name is:\n \"%s\""%str(self.__url))
777 # Directory related tests
778 # -----------------------
779 def is_local_dir(self):
780 if os.path.isdir(self.__url):
784 def is_not_local_dir(self):
785 if not os.path.isdir(self.__url):
789 def raise_error_if_not_local_dir(self):
790 if not os.path.isdir(self.__url):
791 raise ValueError("The name or the url of the directory object doesn't seem to exist. The given name is:\n \"%s\""%str(self.__url))
795 # Mime related functions
796 # ------------------------
797 def get_standard_mime(self):
798 (__mtype, __encoding) = mimetypes.guess_type(self.__url, strict=False)
800 def get_user_mime(self):
801 __fake = "fake."+self.__usr.lower()
802 (__mtype, __encoding) = mimetypes.guess_type(__fake, strict=False)
804 def get_comprehensive_mime(self):
805 if self.get_standard_mime() is not None:
806 return self.get_standard_mime()
807 elif self.get_user_mime() is not None:
808 return self.get_user_mime()
812 # Name related functions
813 # ----------------------
814 def get_user_name(self):
816 def get_absolute_name(self):
817 return os.path.abspath(os.path.realpath(self.__url))
818 def get_extension(self):
821 class ImportFromFile(object):
823 Obtention de variables disrétisées en 1D, définies par une ou des variables
824 nommées, et sous la forme d'une série de points éventuellement indexés. La
825 lecture d'un fichier au format spécifié (ou intuité) permet de charger ces
827 - des fichiers textes en colonnes de type TXT, CSV, TSV...
828 - des fichiers de données binaires NPY, NPZ, SDF...
829 La lecture du fichier complet ne se fait que si nécessaire, pour assurer la
830 performance tout en disposant de l'interprétation du contenu. Les fichiers
831 textes doivent présenter en première ligne (hors commentaire ou ligne vide)
832 les noms des variables de colonnes. Les commentaires commencent par un "#".
835 "_filename", "_colnames", "_colindex", "_varsline", "_format",
836 "_delimiter", "_skiprows", "__url", "__filestring", "__header",
837 "__allowvoid", "__binaryformats", "__supportedformats")
838 def __enter__(self): return self
839 def __exit__(self, exc_type, exc_val, exc_tb): return False
841 def __init__(self, Filename=None, ColNames=None, ColIndex=None, Format="Guess", AllowVoidNameList=True):
843 Verifie l'existence et les informations de définition du fichier. Les
844 noms de colonnes ou de variables sont ignorées si le format ne permet
847 - Filename : nom du fichier
848 - ColNames : noms de la ou des colonnes/variables à lire
849 - ColIndex : nom unique de la colonne/variable servant d'index
850 - Format : format du fichier et/ou des données inclues
851 - AllowVoidNameList : permet, si la liste de noms est vide, de
852 prendre par défaut toutes les colonnes
854 self.__binaryformats =(
855 "application/numpy.npy",
856 "application/numpy.npz",
857 "application/dymola.sdf",
859 self.__url = ImportDetector( Filename, Format)
860 self.__url.raise_error_if_not_local_file()
861 self._filename = self.__url.get_absolute_name()
862 PlatformInfo.checkFileNameConformity( self._filename )
864 self._format = self.__url.get_comprehensive_mime()
866 self.__header, self._varsline, self._skiprows = self.__getentete()
868 if self._format == "text/csv" or Format.upper() == "CSV":
869 self._format = "text/csv"
870 self.__filestring = "".join(self.__header)
871 if self.__filestring.count(",") > 1:
872 self._delimiter = ","
873 elif self.__filestring.count(";") > 1:
874 self._delimiter = ";"
876 self._delimiter = None
877 elif self._format == "text/tab-separated-values" or Format.upper() == "TSV":
878 self._format = "text/tab-separated-values"
879 self._delimiter = "\t"
881 self._delimiter = None
883 if ColNames is not None: self._colnames = tuple(ColNames)
884 else: self._colnames = None
886 if ColIndex is not None: self._colindex = str(ColIndex)
887 else: self._colindex = None
889 self.__allowvoid = bool(AllowVoidNameList)
891 def __getentete(self, __nblines = 3):
892 "Lit l'entête du fichier pour trouver la définition des variables"
893 # La première ligne non vide non commentée est toujours considérée
894 # porter les labels de colonne, donc pas des valeurs
895 __header, __varsline, __skiprows = [], "", 1
896 if self._format in self.__binaryformats:
899 with open(self._filename,'r') as fid:
900 __line = fid.readline().strip()
901 while "#" in __line or len(__line) < 1:
902 __header.append(__line)
904 __line = fid.readline().strip()
906 for i in range(max(0,__nblines)):
907 __header.append(fid.readline())
908 return (__header, __varsline, __skiprows)
910 def __getindices(self, __colnames, __colindex, __delimiter=None ):
911 "Indices de colonnes correspondants à l'index et aux variables"
912 if __delimiter is None:
913 __varserie = self._varsline.strip('#').strip().split()
915 __varserie = self._varsline.strip('#').strip().split(str(__delimiter))
917 if __colnames is not None:
919 __colnames = tuple(__colnames)
921 for i, n in enumerate(__varserie):
922 if v == n: __usecols.append(i)
923 __usecols = tuple(__usecols)
924 if len(__usecols) == 0:
928 raise ValueError("Can not found any column corresponding to the required names %s"%(__colnames,))
932 if __colindex is not None:
934 __colindex = str(__colindex)
935 for i, n in enumerate(__varserie):
936 if __colindex == n: __useindex = i
940 return (__usecols, __useindex)
942 def getsupported(self):
943 self.__supportedformats = {}
944 self.__supportedformats["text/plain"] = True
945 self.__supportedformats["text/csv"] = True
946 self.__supportedformats["text/tab-separated-values"] = True
947 self.__supportedformats["application/numpy.npy"] = True
948 self.__supportedformats["application/numpy.npz"] = True
949 self.__supportedformats["application/dymola.sdf"] = PlatformInfo.has_sdf
950 return self.__supportedformats
952 def getvalue(self, ColNames=None, ColIndex=None ):
953 "Renvoie la ou les variables demandees par la liste de leurs noms"
954 # Uniquement si mise à jour
955 if ColNames is not None: self._colnames = tuple(ColNames)
956 if ColIndex is not None: self._colindex = str(ColIndex)
959 if self._format == "application/numpy.npy":
960 __columns = numpy.load(self._filename)
962 elif self._format == "application/numpy.npz":
964 with numpy.load(self._filename) as __allcolumns:
965 if self._colnames is None:
966 self._colnames = __allcolumns.files
967 for nom in self._colnames: # Si une variable demandée n'existe pas
968 if nom not in __allcolumns.files:
969 self._colnames = tuple( __allcolumns.files )
970 for nom in self._colnames:
971 if nom in __allcolumns.files:
972 if __columns is not None:
973 # Attention : toutes les variables doivent avoir la même taille
974 __columns = numpy.vstack((__columns, numpy.reshape(__allcolumns[nom], (1,-1))))
977 __columns = numpy.reshape(__allcolumns[nom], (1,-1))
978 if self._colindex is not None and self._colindex in __allcolumns.files:
979 __index = numpy.array(numpy.reshape(__allcolumns[self._colindex], (1,-1)), dtype=bytes)
980 elif self._format == "text/plain":
981 __usecols, __useindex = self.__getindices(self._colnames, self._colindex)
982 __columns = numpy.loadtxt(self._filename, usecols = __usecols, skiprows=self._skiprows)
983 if __useindex is not None:
984 __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), skiprows=self._skiprows)
985 if __usecols is None: # Si une variable demandée n'existe pas
986 self._colnames = None
988 elif self._format == "application/dymola.sdf" and PlatformInfo.has_sdf:
990 __content = sdf.load(self._filename)
992 if self._colnames is None:
993 self._colnames = [__content.datasets[i].name for i in range(len(__content.datasets))]
994 for nom in self._colnames:
996 if __columns is not None:
997 # Attention : toutes les variables doivent avoir la même taille
998 __columns = numpy.vstack((__columns, numpy.reshape(__content[nom].data, (1,-1))))
1001 __columns = numpy.reshape(__content[nom].data, (1,-1))
1002 if self._colindex is not None and self._colindex in __content:
1003 __index = __content[self._colindex].data
1005 elif self._format == "text/csv":
1006 __usecols, __useindex = self.__getindices(self._colnames, self._colindex, self._delimiter)
1007 __columns = numpy.loadtxt(self._filename, usecols = __usecols, delimiter = self._delimiter, skiprows=self._skiprows)
1008 if __useindex is not None:
1009 __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), delimiter = self._delimiter, skiprows=self._skiprows)
1010 if __usecols is None: # Si une variable demandée n'existe pas
1011 self._colnames = None
1013 elif self._format == "text/tab-separated-values":
1014 __usecols, __useindex = self.__getindices(self._colnames, self._colindex, self._delimiter)
1015 __columns = numpy.loadtxt(self._filename, usecols = __usecols, delimiter = self._delimiter, skiprows=self._skiprows)
1016 if __useindex is not None:
1017 __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), delimiter = self._delimiter, skiprows=self._skiprows)
1018 if __usecols is None: # Si une variable demandée n'existe pas
1019 self._colnames = None
1021 raise ValueError("Unkown file format \"%s\" or no reader available"%self._format)
1022 if __columns is None: __columns = ()
1024 def toString(value):
1026 return value.decode()
1029 if __index is not None:
1030 __index = tuple([toString(v) for v in __index])
1032 return (self._colnames, __columns, self._colindex, __index)
1034 def getstring(self):
1035 "Renvoie le fichier texte complet"
1036 if self._format in self.__binaryformats:
1039 with open(self._filename,'r') as fid:
1042 def getformat(self):
1045 class ImportScalarLinesFromFile(ImportFromFile):
1047 Importation de fichier contenant des variables scalaires nommées. Le
1048 fichier comporte soit 2, soit 4 colonnes, obligatoirement nommées "Name",
1049 "Value", "Minimum", "Maximum" si les noms sont précisés. Sur chaque ligne
1050 est indiqué le nom, la valeur, et éventuelement deux bornes min et max (ou
1051 None si nécessaire pour une borne).
1053 Seule la méthode "getvalue" est changée.
1055 def __enter__(self): return self
1056 def __exit__(self, exc_type, exc_val, exc_tb): return False
1058 def __init__(self, Filename=None, ColNames=None, ColIndex=None, Format="Guess"):
1059 ImportFromFile.__init__(self, Filename, ColNames, ColIndex, Format)
1060 if self._format not in ["text/plain", "text/csv", "text/tab-separated-values"]:
1061 raise ValueError("Unkown file format \"%s\""%self._format)
1063 def getvalue(self, VarNames = None, HeaderNames=()):
1064 "Renvoie la ou les variables demandees par la liste de leurs noms"
1065 if VarNames is not None: __varnames = tuple(VarNames)
1066 else: __varnames = None
1068 if "Name" in self._varsline and "Value" in self._varsline and "Minimum" in self._varsline and "Maximum" in self._varsline:
1069 __ftype = "NamValMinMax"
1070 __dtypes = {'names' : ('Name', 'Value', 'Minimum', 'Maximum'),
1071 'formats': ('S128', 'g', 'g', 'g')}
1072 __usecols = (0, 1, 2, 3)
1073 def __replaceNoneN( s ):
1074 if s.strip() == b'None': return numpy.NINF
1076 def __replaceNoneP( s ):
1077 if s.strip() == b'None': return numpy.PINF
1079 __converters = {2: __replaceNoneN, 3: __replaceNoneP}
1080 elif "Name" in self._varsline and "Value" in self._varsline and ("Minimum" not in self._varsline or "Maximum" not in self._varsline):
1082 __dtypes = {'names' : ('Name', 'Value'),
1083 'formats': ('S128', 'g')}
1086 elif len(HeaderNames)>0 and numpy.all([kw in self._varsline for kw in HeaderNames]):
1087 __ftype = "NamLotOfVals"
1088 __dtypes = {'names' : HeaderNames,
1089 'formats': tuple(['S128',]+['g']*(len(HeaderNames)-1))}
1090 __usecols = tuple(range(len(HeaderNames)))
1091 def __replaceNone( s ):
1092 if s.strip() == b'None': return numpy.NAN
1094 __converters = dict()
1095 for i in range(1,len(HeaderNames)):
1096 __converters[i] = __replaceNone
1098 raise ValueError("Can not find names of columns for initial values. Wrong first line is:\n \"%s\""%__firstline)
1100 if self._format == "text/plain":
1101 __content = numpy.loadtxt(self._filename, dtype = __dtypes, usecols = __usecols, skiprows = self._skiprows, converters = __converters)
1102 elif self._format in ["text/csv", "text/tab-separated-values"]:
1103 __content = numpy.loadtxt(self._filename, dtype = __dtypes, usecols = __usecols, skiprows = self._skiprows, converters = __converters, delimiter = self._delimiter)
1105 raise ValueError("Unkown file format \"%s\""%self._format)
1107 __names, __thevalue, __bounds = [], [], []
1108 for sub in __content:
1109 if len(__usecols) == 4:
1110 na, va, mi, ma = sub
1111 if numpy.isneginf(mi): mi = None # Réattribue les variables None
1112 elif numpy.isnan(mi): mi = None # Réattribue les variables None
1113 if numpy.isposinf(ma): ma = None # Réattribue les variables None
1114 elif numpy.isnan(ma): ma = None # Réattribue les variables None
1115 elif len(__usecols) == 2 and __ftype == "NamVal":
1121 for i, v in enumerate(nsub[1:]):
1122 if numpy.isnan(v): nsub[i+1] = None
1126 if (__varnames is None or na in __varnames) and (na not in __names):
1127 # Ne stocke que la premiere occurence d'une variable
1129 __thevalue.append(va)
1130 __bounds.append((mi,ma))
1132 __names = tuple(__names)
1133 __thevalue = numpy.array(__thevalue)
1134 __bounds = tuple(__bounds)
1136 return (__names, __thevalue, __bounds)
1138 # ==============================================================================
1139 class EficasGUI(object):
1141 Lancement autonome de l'interface EFICAS/ADAO
1143 def __init__(self, __addpath = None):
1144 # Chemin pour l'installation (ordre important)
1146 self.__path_settings_ok = False
1148 if "EFICAS_ROOT" in os.environ:
1149 __EFICAS_ROOT = os.environ["EFICAS_ROOT"]
1152 self.__msg += "\nKeyError:\n"+\
1153 " the required environment variable EFICAS_ROOT is unknown.\n"+\
1154 " You have either to be in SALOME environment, or to set\n"+\
1155 " this variable in your environment to the right path \"<...>\"\n"+\
1156 " to find an installed EFICAS application. For example:\n"+\
1157 " EFICAS_ROOT=\"<...>\" command\n"
1161 __path_ok = True and __path_ok
1163 self.__msg += "\nImportError:\n"+\
1164 " the required ADAO library can not be found to be imported.\n"+\
1165 " You have either to be in ADAO environment, or to be in SALOME\n"+\
1166 " environment, or to set manually in your Python 3 environment the\n"+\
1167 " right path \"<...>\" to find an installed ADAO application. For\n"+\
1169 " PYTHONPATH=\"<...>:${PYTHONPATH}\" command\n"
1173 __path_ok = True and __path_ok
1175 self.__msg += "\nImportError:\n"+\
1176 " the required PyQt5 library can not be found to be imported.\n"+\
1177 " You have either to have a raisonable up-to-date Python 3\n"+\
1178 " installation (less than 5 years), or to be in SALOME environment.\n"
1182 self.__msg += "\nWarning:\n"+\
1183 " It seems you have some troubles with your installation.\n"+\
1184 " Be aware that some other errors may exist, that are not\n"+\
1185 " explained as above, like some incomplete or obsolete\n"+\
1186 " Python 3, or incomplete module installation.\n"+\
1188 " Please correct the above error(s) before launching the\n"+\
1189 " standalone EFICAS/ADAO interface.\n"
1190 logging.debug("Some of the ADAO/EFICAS/QT5 paths have not been found")
1191 self.__path_settings_ok = False
1193 logging.debug("All the ADAO/EFICAS/QT5 paths have been found")
1194 self.__path_settings_ok = True
1196 if self.__path_settings_ok:
1197 sys.path.insert(0,__EFICAS_ROOT)
1198 sys.path.insert(0,os.path.join(adao.adao_py_dir,"daEficas"))
1199 if __addpath is not None and os.path.exists(os.path.abspath(__addpath)):
1200 sys.path.insert(0,os.path.abspath(__addpath))
1201 logging.debug("All the paths have been correctly set up")
1204 logging.debug("Errors in path settings have been found")
1207 if self.__path_settings_ok:
1208 logging.debug("Launching standalone EFICAS/ADAO interface...")
1209 from daEficas import prefs
1210 from InterfaceQT4 import eficas_go
1211 eficas_go.lanceEficas(code=prefs.code)
1213 logging.debug("Can not launch standalone EFICAS/ADAO interface for path errors.")
1215 # ==============================================================================
1216 if __name__ == "__main__":
1217 print('\n AUTODIAGNOSTIC\n')